1 /*
2 * Copyright (c) 2004, 2005, Oracle and/or its affiliates. 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.tools.apt.mirror.util;
27
28
29 import java.util.Collection;
30
31 import com.sun.mirror.declaration.*;
32 import com.sun.mirror.type.*;
33 import com.sun.mirror.util.Types;
34 import com.sun.tools.apt.mirror.AptEnv;
35 import com.sun.tools.apt.mirror.declaration.*;
36 import com.sun.tools.apt.mirror.type.TypeMirrorImpl;
37 import com.sun.tools.javac.code.BoundKind;
38 import com.sun.tools.javac.code.Type;
39 import com.sun.tools.javac.code.Symbol.ClassSymbol;
40 import com.sun.tools.javac.util.Context;
41 import com.sun.tools.javac.util.ListBuffer;
42
43
44 /**
45 * Implementation of Types utility methods for annotation processors
46 */
47 @SuppressWarnings("deprecation")
48 public class TypesImpl implements Types {
49
50 private final AptEnv env;
51
52
53 private static final Context.Key<Types> typesKey =
54 new Context.Key<Types>();
55
56 public static Types instance(Context context) {
57 Types instance = context.get(typesKey);
58 if (instance == null) {
59 instance = new TypesImpl(context);
60 }
61 return instance;
62 }
63
64 private TypesImpl(Context context) {
65 context.put(typesKey, this);
66 env = AptEnv.instance(context);
67 }
68
69
70 /**
71 * {@inheritDoc}
72 */
73 public boolean isSubtype(TypeMirror t1, TypeMirror t2) {
74 return env.jctypes.isSubtype(((TypeMirrorImpl) t1).type,
75 ((TypeMirrorImpl) t2).type);
76 }
77
78 /**
79 * {@inheritDoc}
80 */
81 public boolean isAssignable(TypeMirror t1, TypeMirror t2) {
82 return env.jctypes.isAssignable(((TypeMirrorImpl) t1).type,
83 ((TypeMirrorImpl) t2).type);
84 }
85
86 /**
87 * {@inheritDoc}
88 */
89 public TypeMirror getErasure(TypeMirror t) {
90 return env.typeMaker.getType(
91 env.jctypes.erasure(((TypeMirrorImpl) t).type));
92 }
93
94 /**
95 * {@inheritDoc}
96 */
97 public PrimitiveType getPrimitiveType(PrimitiveType.Kind kind) {
98 Type prim = null;
99 switch (kind) {
100 case BOOLEAN: prim = env.symtab.booleanType; break;
101 case BYTE: prim = env.symtab.byteType; break;
102 case SHORT: prim = env.symtab.shortType; break;
103 case INT: prim = env.symtab.intType; break;
104 case LONG: prim = env.symtab.longType; break;
105 case CHAR: prim = env.symtab.charType; break;
106 case FLOAT: prim = env.symtab.floatType; break;
107 case DOUBLE: prim = env.symtab.doubleType; break;
108 default: assert false;
109 }
110 return (PrimitiveType) env.typeMaker.getType(prim);
111 }
112
113 /**
114 * {@inheritDoc}
115 */
116 public VoidType getVoidType() {
117 return (VoidType) env.typeMaker.getType(env.symtab.voidType);
118 }
119
120 /**
121 * {@inheritDoc}
122 */
123 public ArrayType getArrayType(TypeMirror componentType) {
124 if (componentType instanceof VoidType) {
125 throw new IllegalArgumentException("void");
126 }
127 return (ArrayType) env.typeMaker.getType(
128 new Type.ArrayType(((TypeMirrorImpl) componentType).type,
129 env.symtab.arrayClass));
130 }
131
132 /**
133 * {@inheritDoc}
134 */
135 public TypeVariable getTypeVariable(TypeParameterDeclaration tparam) {
136 return (TypeVariable) env.typeMaker.getType(
137 ((DeclarationImpl) tparam).sym.type);
138 }
139
140 /**
141 * {@inheritDoc}
142 */
143 public WildcardType getWildcardType(Collection<ReferenceType> upperBounds,
144 Collection<ReferenceType> lowerBounds) {
145 BoundKind kind;
146 Type bound;
147 int uppers = upperBounds.size();
148 int downers = lowerBounds.size();
149
150 if (uppers + downers > 1) {
151 throw new IllegalArgumentException("Multiple bounds not allowed");
152
153 } else if (uppers + downers == 0) {
154 kind = BoundKind.UNBOUND;
155 bound = env.symtab.objectType;
156
157 } else if (uppers == 1) {
158 assert downers == 0;
159 kind = BoundKind.EXTENDS;
160 bound = ((TypeMirrorImpl) upperBounds.iterator().next()).type;
161
162 } else {
163 assert uppers == 0 && downers == 1;
164 kind = BoundKind.SUPER;
165 bound = ((TypeMirrorImpl) lowerBounds.iterator().next()).type;
166 }
167
168 if (bound instanceof Type.WildcardType)
169 throw new IllegalArgumentException(bound.toString());
170
171 return (WildcardType) env.typeMaker.getType(
172 new Type.WildcardType(bound, kind, env.symtab.boundClass));
173 }
174
175 /**
176 * {@inheritDoc}
177 */
178 public DeclaredType getDeclaredType(TypeDeclaration decl,
179 TypeMirror... typeArgs) {
180 ClassSymbol sym = ((TypeDeclarationImpl) decl).sym;
181
182 if (typeArgs.length == 0)
183 return (DeclaredType) env.typeMaker.getType(
184 env.jctypes.erasure(sym.type));
185 if (sym.type.getEnclosingType().isParameterized())
186 throw new IllegalArgumentException(decl.toString());
187
188 return getDeclaredType(sym.type.getEnclosingType(), sym, typeArgs);
189 }
190
191 /**
192 * {@inheritDoc}
193 */
194 public DeclaredType getDeclaredType(DeclaredType containing,
195 TypeDeclaration decl,
196 TypeMirror... typeArgs) {
197 if (containing == null)
198 return getDeclaredType(decl, typeArgs);
199
200 ClassSymbol sym = ((TypeDeclarationImpl) decl).sym;
201 Type outer = ((TypeMirrorImpl) containing).type;
202
203 if (outer.tsym != sym.owner.enclClass())
204 throw new IllegalArgumentException(containing.toString());
205 if (!outer.isParameterized())
206 return getDeclaredType(decl, typeArgs);
207
208 return getDeclaredType(outer, sym, typeArgs);
209 }
210
211 private DeclaredType getDeclaredType(Type outer,
212 ClassSymbol sym,
213 TypeMirror... typeArgs) {
214 if (typeArgs.length != sym.type.getTypeArguments().length())
215 throw new IllegalArgumentException(
216 "Incorrect number of type arguments");
217
218 ListBuffer<Type> targs = new ListBuffer<Type>();
219 for (TypeMirror t : typeArgs) {
220 if (!(t instanceof ReferenceType || t instanceof WildcardType))
221 throw new IllegalArgumentException(t.toString());
222 targs.append(((TypeMirrorImpl) t).type);
223 }
224 //### Need a way to check that type args match formals.
225
226 return (DeclaredType) env.typeMaker.getType(
227 new Type.ClassType(outer, targs.toList(), sym));
228 }
229 }