EMMA Coverage Report (generated Thu Dec 06 15:52:10 GMT 2007)
[all classes][com.sun.tools.javac.model]

COVERAGE SUMMARY FOR SOURCE FILE [JavacTypes.java]

nameclass, %method, %block, %line, %
JavacTypes.java50%  (1/2)11%  (3/27)4%   (24/668)7%   (8/109)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class JavacTypes$10%   (0/1)0%   (0/1)0%   (0/124)0%   (0/1)
<static initializer> 0%   (0/1)0%   (0/124)0%   (0/1)
     
class JavacTypes100% (1/1)12%  (3/26)4%   (24/544)7%   (8/109)
asElement (TypeMirror): Element 0%   (0/1)0%   (0/18)0%   (0/4)
asMemberOf (DeclaredType, Element): TypeMirror 0%   (0/1)0%   (0/33)0%   (0/5)
boxedClass (PrimitiveType): TypeElement 0%   (0/1)0%   (0/6)0%   (0/1)
capture (TypeMirror): TypeMirror 0%   (0/1)0%   (0/10)0%   (0/2)
cast (Class, Object): Object 0%   (0/1)0%   (0/14)0%   (0/3)
contains (TypeMirror, TypeMirror): boolean 0%   (0/1)0%   (0/14)0%   (0/3)
directSupertypes (TypeMirror): List 0%   (0/1)0%   (0/32)0%   (0/4)
erasure (TypeMirror): TypeMirror 0%   (0/1)0%   (0/16)0%   (0/3)
getArrayType (TypeMirror): ArrayType 0%   (0/1)0%   (0/21)0%   (0/3)
getDeclaredType (DeclaredType, TypeElement, TypeMirror []): DeclaredType 0%   (0/1)0%   (0/39)0%   (0/9)
getDeclaredType (TypeElement, TypeMirror []): DeclaredType 0%   (0/1)0%   (0/31)0%   (0/6)
getDeclaredType0 (Type, Symbol$ClassSymbol, TypeMirror []): DeclaredType 0%   (0/1)0%   (0/57)0%   (0/8)
getNoType (TypeKind): NoType 0%   (0/1)0%   (0/17)0%   (0/4)
getNullType (): NullType 0%   (0/1)0%   (0/5)0%   (0/1)
getPrimitiveType (TypeKind): PrimitiveType 0%   (0/1)0%   (0/49)0%   (0/10)
getWildcardType (TypeMirror, TypeMirror): WildcardType 0%   (0/1)0%   (0/53)0%   (0/13)
instance (Context): JavacTypes 0%   (0/1)0%   (0/18)0%   (0/5)
isAssignable (TypeMirror, TypeMirror): boolean 0%   (0/1)0%   (0/16)0%   (0/3)
isSameType (TypeMirror, TypeMirror): boolean 0%   (0/1)0%   (0/8)0%   (0/1)
isSubsignature (ExecutableType, ExecutableType): boolean 0%   (0/1)0%   (0/8)0%   (0/1)
isSubtype (TypeMirror, TypeMirror): boolean 0%   (0/1)0%   (0/16)0%   (0/3)
unboxedType (TypeMirror): PrimitiveType 0%   (0/1)0%   (0/27)0%   (0/6)
validateTypeNotIn (TypeMirror, Set): void 0%   (0/1)0%   (0/12)0%   (0/3)
<static initializer> 100% (1/1)100% (9/9)100% (2/2)
JavacTypes (Context): void 100% (1/1)100% (6/6)100% (3/3)
setContext (Context): void 100% (1/1)100% (9/9)100% (3/3)

1/*
2 * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25 
26package com.sun.tools.javac.model;
27 
28import java.util.List;
29import java.util.Set;
30import java.util.EnumSet;
31import javax.lang.model.element.*;
32import javax.lang.model.type.*;
33import com.sun.tools.javac.code.*;
34import com.sun.tools.javac.code.Symbol.*;
35import com.sun.tools.javac.util.*;
36 
37/**
38 * Utility methods for operating on types.
39 *
40 * <p><b>This is NOT part of any API supported by Sun Microsystems.
41 * If you write code that depends on this, you do so at your own
42 * risk.  This code and its internal interfaces are subject to change
43 * or deletion without notice.</b></p>
44 */
45public class JavacTypes implements javax.lang.model.util.Types {
46 
47    private Symtab syms;
48    private Types types;
49 
50    private static final Context.Key<JavacTypes> KEY =
51            new Context.Key<JavacTypes>();
52 
53    public static JavacTypes instance(Context context) {
54        JavacTypes instance = context.get(KEY);
55        if (instance == null) {
56            instance = new JavacTypes(context);
57            context.put(KEY, instance);
58        }
59        return instance;
60    }
61 
62    /**
63     * Public for use only by JavacProcessingEnvironment
64     */
65    // TODO JavacTypes constructor should be protected
66    public JavacTypes(Context context) {
67        setContext(context);
68    }
69 
70    /**
71     * Use a new context.  May be called from outside to update
72     * internal state for a new annotation-processing round.
73     * This instance is *not* then registered with the new context.
74     */
75    public void setContext(Context context) {
76        syms = Symtab.instance(context);
77        types = Types.instance(context);
78    }
79 
80    public Element asElement(TypeMirror t) {
81        Type type = cast(Type.class, t);
82        if (type.tag != TypeTags.CLASS && type.tag != TypeTags.TYPEVAR)
83            return null;
84        return type.asElement();
85    }
86 
87    public boolean isSameType(TypeMirror t1, TypeMirror t2) {
88        return types.isSameType((Type) t1, (Type) t2);
89    }
90 
91    public boolean isSubtype(TypeMirror t1, TypeMirror t2) {
92        validateTypeNotIn(t1, EXEC_OR_PKG);
93        validateTypeNotIn(t2, EXEC_OR_PKG);
94        return types.isSubtype((Type) t1, (Type) t2);
95    }
96 
97    public boolean isAssignable(TypeMirror t1, TypeMirror t2) {
98        validateTypeNotIn(t1, EXEC_OR_PKG);
99        validateTypeNotIn(t2, EXEC_OR_PKG);
100        return types.isAssignable((Type) t1, (Type) t2);
101    }
102 
103    public boolean contains(TypeMirror t1, TypeMirror t2) {
104        validateTypeNotIn(t1, EXEC_OR_PKG);
105        validateTypeNotIn(t2, EXEC_OR_PKG);
106        return ((Type) t1).contains((Type) t2);
107    }
108 
109    public boolean isSubsignature(ExecutableType m1, ExecutableType m2) {
110        return types.isSubSignature((Type) m1, (Type) m2);
111    }
112 
113    public List<Type> directSupertypes(TypeMirror t) {
114        validateTypeNotIn(t, EXEC_OR_PKG);
115        Type type = (Type) t;
116        Type sup = types.supertype(type);
117        return (sup == Type.noType || sup == type || sup == null)
118              ? types.interfaces(type)
119              : types.interfaces(type).prepend(sup);
120    }
121 
122    public TypeMirror erasure(TypeMirror t) {
123        if (t.getKind() == TypeKind.PACKAGE)
124            throw new IllegalArgumentException(t.toString());
125        return types.erasure((Type) t);
126    }
127 
128    public TypeElement boxedClass(PrimitiveType p) {
129        return types.boxedClass((Type) p);
130    }
131 
132    public PrimitiveType unboxedType(TypeMirror t) {
133        if (t.getKind() != TypeKind.DECLARED)
134            throw new IllegalArgumentException(t.toString());
135        Type unboxed = types.unboxedType((Type) t);
136        if (! unboxed.isPrimitive())    // only true primitives, not void
137            throw new IllegalArgumentException(t.toString());
138        return unboxed;
139    }
140 
141    public TypeMirror capture(TypeMirror t) {
142        validateTypeNotIn(t, EXEC_OR_PKG);
143        return types.capture((Type) t);
144    }
145 
146    public PrimitiveType getPrimitiveType(TypeKind kind) {
147        switch (kind) {
148        case BOOLEAN:   return syms.booleanType;
149        case BYTE:      return syms.byteType;
150        case SHORT:     return syms.shortType;
151        case INT:       return syms.intType;
152        case LONG:      return syms.longType;
153        case CHAR:      return syms.charType;
154        case FLOAT:     return syms.floatType;
155        case DOUBLE:    return syms.doubleType;
156        default:
157            throw new IllegalArgumentException("Not a primitive type: " + kind);
158        }
159    }
160 
161    public NullType getNullType() {
162        return (NullType) syms.botType;
163    }
164 
165    public NoType getNoType(TypeKind kind) {
166        switch (kind) {
167        case VOID:      return syms.voidType;
168        case NONE:      return Type.noType;
169        default:
170            throw new IllegalArgumentException(kind.toString());
171        }
172    }
173 
174    public ArrayType getArrayType(TypeMirror componentType) {
175        switch (componentType.getKind()) {
176        case VOID:
177        case EXECUTABLE:
178        case WILDCARD:  // heh!
179        case PACKAGE:
180            throw new IllegalArgumentException(componentType.toString());
181        }
182        return new Type.ArrayType((Type) componentType, syms.arrayClass);
183    }
184 
185    public WildcardType getWildcardType(TypeMirror extendsBound,
186                                        TypeMirror superBound) {
187        BoundKind bkind;
188        Type bound;
189        if (extendsBound == null && superBound == null) {
190            bkind = BoundKind.UNBOUND;
191            bound = syms.objectType;
192        } else if (superBound == null) {
193            bkind = BoundKind.EXTENDS;
194            bound = (Type) extendsBound;
195        } else if (extendsBound == null) {
196            bkind = BoundKind.SUPER;
197            bound = (Type) superBound;
198        } else {
199            throw new IllegalArgumentException(
200                    "Extends and super bounds cannot both be provided");
201        }
202        switch (bound.getKind()) {
203        case ARRAY:
204        case DECLARED:
205        case ERROR:
206        case TYPEVAR:
207            return new Type.WildcardType(bound, bkind, syms.boundClass);
208        default:
209            throw new IllegalArgumentException(bound.toString());
210        }
211    }
212 
213    public DeclaredType getDeclaredType(TypeElement typeElem,
214                                        TypeMirror... typeArgs) {
215        ClassSymbol sym = (ClassSymbol) typeElem;
216 
217        if (typeArgs.length == 0)
218            return (DeclaredType) sym.erasure(types);
219        if (sym.type.getEnclosingType().isParameterized())
220            throw new IllegalArgumentException(sym.toString());
221 
222        return getDeclaredType0(sym.type.getEnclosingType(), sym, typeArgs);
223    }
224 
225    public DeclaredType getDeclaredType(DeclaredType enclosing,
226                                        TypeElement typeElem,
227                                        TypeMirror... typeArgs) {
228        if (enclosing == null)
229            return getDeclaredType(typeElem, typeArgs);
230 
231        ClassSymbol sym = (ClassSymbol) typeElem;
232        Type outer = (Type) enclosing;
233 
234        if (outer.tsym != sym.owner.enclClass())
235            throw new IllegalArgumentException(enclosing.toString());
236        if (!outer.isParameterized())
237            return getDeclaredType(typeElem, typeArgs);
238 
239        return getDeclaredType0(outer, sym, typeArgs);
240    }
241    // where
242        private DeclaredType getDeclaredType0(Type outer,
243                                              ClassSymbol sym,
244                                              TypeMirror... typeArgs) {
245            if (typeArgs.length != sym.type.getTypeArguments().length())
246                throw new IllegalArgumentException(
247                "Incorrect number of type arguments");
248 
249            ListBuffer<Type> targs = new ListBuffer<Type>();
250            for (TypeMirror t : typeArgs) {
251                if (!(t instanceof ReferenceType || t instanceof WildcardType))
252                    throw new IllegalArgumentException(t.toString());
253                targs.append((Type) t);
254            }
255            // TODO: Would like a way to check that type args match formals.
256 
257            return (DeclaredType) new Type.ClassType(outer, targs.toList(), sym);
258        }
259 
260    /**
261     * Returns the type of an element when that element is viewed as
262     * a member of, or otherwise directly contained by, a given type.
263     * For example,
264     * when viewed as a member of the parameterized type {@code Set<String>},
265     * the {@code Set.add} method is an {@code ExecutableType}
266     * whose parameter is of type {@code String}.
267     *
268     * @param containing  the containing type
269     * @param element     the element
270     * @return the type of the element as viewed from the containing type
271     * @throws IllegalArgumentException if the element is not a valid one
272     *          for the given type
273     */
274    public TypeMirror asMemberOf(DeclaredType containing, Element element) {
275        Type site = (Type)containing;
276        Symbol sym = (Symbol)element;
277        if (types.asSuper(site, sym.getEnclosingElement()) == null)
278            throw new IllegalArgumentException(sym + "@" + site);
279        return types.memberType(site, sym);
280    }
281 
282 
283    private static final Set<TypeKind> EXEC_OR_PKG =
284            EnumSet.of(TypeKind.EXECUTABLE, TypeKind.PACKAGE);
285 
286    /**
287     * Throws an IllegalArgumentException if a type's kind is one of a set.
288     */
289    private void validateTypeNotIn(TypeMirror t, Set<TypeKind> invalidKinds) {
290        if (invalidKinds.contains(t.getKind()))
291            throw new IllegalArgumentException(t.toString());
292    }
293 
294    /**
295     * Returns an object cast to the specified type.
296     * @throws NullPointerException if the object is {@code null}
297     * @throws IllegalArgumentException if the object is of the wrong type
298     */
299    private static <T> T cast(Class<T> clazz, Object o) {
300        if (! clazz.isInstance(o))
301            throw new IllegalArgumentException(o.toString());
302        return clazz.cast(o);
303    }
304}

[all classes][com.sun.tools.javac.model]
EMMA 2.0.5312 (C) Vladimir Roubtsov