1 /*
2 * Copyright (c) 2005, 2017, 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 javax.lang.model.util;
27
28 import javax.annotation.processing.SupportedSourceVersion;
29 import javax.lang.model.SourceVersion;
30 import javax.lang.model.type.*;
31 import static javax.lang.model.SourceVersion.*;
32
33 /**
34 * A visitor of types based on their {@linkplain TypeKind kind} with
35 * default behavior appropriate for the {@link SourceVersion#RELEASE_6
36 * RELEASE_6} source version. For {@linkplain
37 * TypeMirror types} <code><i>Xyz</i></code> that may have more than one
38 * kind, the <code>visit<i>Xyz</i></code> methods in this class delegate
39 * to the <code>visit<i>Xyz</i>As<i>Kind</i></code> method corresponding to the
40 * first argument's kind. The <code>visit<i>Xyz</i>As<i>Kind</i></code> methods
41 * call {@link #defaultAction defaultAction}, passing their arguments
42 * to {@code defaultAction}'s corresponding parameters.
43 *
44 * <p> Methods in this class may be overridden subject to their
45 * general contract. Note that annotating methods in concrete
46 * subclasses with {@link java.lang.Override @Override} will help
47 * ensure that methods are overridden as intended.
48 *
49 * <p> <b>WARNING:</b> The {@code TypeVisitor} interface implemented
50 * by this class may have methods added to it in the future to
51 * accommodate new, currently unknown, language structures added to
52 * future versions of the Java™ programming language.
53 * Therefore, methods whose names begin with {@code "visit"} may be
54 * added to this class in the future; to avoid incompatibilities,
55 * classes which extend this class should not declare any instance
56 * methods with names beginning with {@code "visit"}.
57 *
58 * <p>When such a new visit method is added, the default
59 * implementation in this class will be to call the {@link
60 * #visitUnknown visitUnknown} method. A new type kind visitor class
61 * will also be introduced to correspond to the new language level;
62 * this visitor will have different default behavior for the visit
63 * method in question. When the new visitor is introduced, all or
64 * portions of this visitor may be deprecated.
65 *
66 * @param <R> the return type of this visitor's methods. Use {@link
67 * Void} for visitors that do not need to return results.
68 * @param <P> the type of the additional parameter to this visitor's
69 * methods. Use {@code Void} for visitors that do not need an
70 * additional parameter.
71 *
72 * @author Joseph D. Darcy
73 * @author Scott Seligman
74 * @author Peter von der Ahé
75 *
76 * @see TypeKindVisitor7
77 * @see TypeKindVisitor8
78 * @since 1.6
79 */
80 @SupportedSourceVersion(RELEASE_6)
81 public class TypeKindVisitor6<R, P> extends SimpleTypeVisitor6<R, P> {
82 /**
83 * Constructor for concrete subclasses to call; uses {@code null}
84 * for the default value.
85 * @deprecated Release 6 is obsolete; update to a visitor for a newer
86 * release level.
87 */
88 @Deprecated(since="9")
89 protected TypeKindVisitor6() {
90 super(null);
91 }
92
93
94 /**
95 * Constructor for concrete subclasses to call; uses the argument
96 * for the default value.
97 *
98 * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
99 * @deprecated Release 6 is obsolete; update to a visitor for a newer
100 * release level.
101 */
102 @Deprecated(since="9")
103 protected TypeKindVisitor6(R defaultValue) {
104 super(defaultValue);
105 }
106
107 /**
108 * {@inheritDoc}
109 *
110 * @implSpec This implementation dispatches to the visit method for
111 * the specific {@linkplain TypeKind kind} of primitive type:
112 * {@code BOOLEAN}, {@code BYTE}, etc.
113 *
114 * @param t {@inheritDoc}
115 * @param p {@inheritDoc}
116 * @return the result of the kind-specific visit method
117 */
118 @Override
119 public R visitPrimitive(PrimitiveType t, P p) {
120 TypeKind k = t.getKind();
121 switch (k) {
122 case BOOLEAN:
123 return visitPrimitiveAsBoolean(t, p);
124
125 case BYTE:
126 return visitPrimitiveAsByte(t, p);
127
128 case SHORT:
129 return visitPrimitiveAsShort(t, p);
130
131 case INT:
132 return visitPrimitiveAsInt(t, p);
133
134 case LONG:
135 return visitPrimitiveAsLong(t, p);
136
137 case CHAR:
138 return visitPrimitiveAsChar(t, p);
139
140 case FLOAT:
141 return visitPrimitiveAsFloat(t, p);
142
143 case DOUBLE:
144 return visitPrimitiveAsDouble(t, p);
145
146 default:
147 throw new AssertionError("Bad kind " + k + " for PrimitiveType" + t);
148 }
149 }
150
151 /**
152 * Visits a {@code BOOLEAN} primitive type.
153 *
154 * @implSpec This implementation calls {@code defaultAction}.
155 *
156 * @param t the type to visit
157 * @param p a visitor-specified parameter
158 * @return the result of {@code defaultAction}
159 */
160 public R visitPrimitiveAsBoolean(PrimitiveType t, P p) {
161 return defaultAction(t, p);
162 }
163
164 /**
165 * Visits a {@code BYTE} primitive type.
166 *
167 * @implSpec This implementation calls {@code defaultAction}.
168 *
169 * @param t the type to visit
170 * @param p a visitor-specified parameter
171 * @return the result of {@code defaultAction}
172 */
173 public R visitPrimitiveAsByte(PrimitiveType t, P p) {
174 return defaultAction(t, p);
175 }
176
177 /**
178 * Visits a {@code SHORT} primitive type.
179 *
180 * @implSpec This implementation calls {@code defaultAction}.
181 *
182 * @param t the type to visit
183 * @param p a visitor-specified parameter
184 * @return the result of {@code defaultAction}
185 */
186 public R visitPrimitiveAsShort(PrimitiveType t, P p) {
187 return defaultAction(t, p);
188 }
189
190 /**
191 * Visits an {@code INT} primitive type.
192 *
193 * @implSpec This implementation calls {@code defaultAction}.
194 *
195 * @param t the type to visit
196 * @param p a visitor-specified parameter
197 * @return the result of {@code defaultAction}
198 */
199 public R visitPrimitiveAsInt(PrimitiveType t, P p) {
200 return defaultAction(t, p);
201 }
202
203 /**
204 * Visits a {@code LONG} primitive type.
205 *
206 * @implSpec This implementation calls {@code defaultAction}.
207 *
208 * @param t the type to visit
209 * @param p a visitor-specified parameter
210 * @return the result of {@code defaultAction}
211 */
212 public R visitPrimitiveAsLong(PrimitiveType t, P p) {
213 return defaultAction(t, p);
214 }
215
216 /**
217 * Visits a {@code CHAR} primitive type.
218 *
219 * @implSpec This implementation calls {@code defaultAction}.
220 *
221 * @param t the type to visit
222 * @param p a visitor-specified parameter
223 * @return the result of {@code defaultAction}
224 */
225 public R visitPrimitiveAsChar(PrimitiveType t, P p) {
226 return defaultAction(t, p);
227 }
228
229 /**
230 * Visits a {@code FLOAT} primitive type.
231 *
232 * @implSpec This implementation calls {@code defaultAction}.
233 *
234 * @param t the type to visit
235 * @param p a visitor-specified parameter
236 * @return the result of {@code defaultAction}
237 */
238 public R visitPrimitiveAsFloat(PrimitiveType t, P p) {
239 return defaultAction(t, p);
240 }
241
242 /**
243 * Visits a {@code DOUBLE} primitive type.
244 *
245 * @implSpec This implementation calls {@code defaultAction}.
246 *
247 * @param t the type to visit
248 * @param p a visitor-specified parameter
249 * @return the result of {@code defaultAction}
250 */
251 public R visitPrimitiveAsDouble(PrimitiveType t, P p) {
252 return defaultAction(t, p);
253 }
254
255 /**
256 * {@inheritDoc}
257 *
258 * @implSpec This implementation dispatches to the visit method for
259 * the specific {@linkplain TypeKind kind} of pseudo-type:
260 * {@code VOID}, {@code PACKAGE}, {@code MODULE}, or {@code NONE}.
261 *
262 * @param t {@inheritDoc}
263 * @param p {@inheritDoc}
264 * @return the result of the kind-specific visit method
265 */
266 @Override
267 public R visitNoType(NoType t, P p) {
268 TypeKind k = t.getKind();
269 switch (k) {
270 case VOID:
271 return visitNoTypeAsVoid(t, p);
272
273 case PACKAGE:
274 return visitNoTypeAsPackage(t, p);
275
276 case MODULE:
277 return visitNoTypeAsModule(t, p);
278
279 case NONE:
280 return visitNoTypeAsNone(t, p);
281
282 default:
283 throw new AssertionError("Bad kind " + k + " for NoType" + t);
284 }
285 }
286
287 /**
288 * Visits a {@link TypeKind#VOID VOID} pseudo-type.
289 *
290 * @implSpec This implementation calls {@code defaultAction}.
291 *
292 * @param t the type to visit
293 * @param p a visitor-specified parameter
294 * @return the result of {@code defaultAction}
295 */
296 public R visitNoTypeAsVoid(NoType t, P p) {
297 return defaultAction(t, p);
298 }
299
300 /**
301 * Visits a {@link TypeKind#PACKAGE PACKAGE} pseudo-type.
302 *
303 * @implSpec This implementation calls {@code defaultAction}.
304 *
305 * @param t the type to visit
306 * @param p a visitor-specified parameter
307 * @return the result of {@code defaultAction}
308 */
309 public R visitNoTypeAsPackage(NoType t, P p) {
310 return defaultAction(t, p);
311 }
312
313 /**
314 * Visits a {@link TypeKind#MODULE MODULE} pseudo-type.
315 *
316 * @implSpec This implementation calls {@code visitUnknown}.
317 *
318 * @param t the type to visit
319 * @param p a visitor-specified parameter
320 * @return the result of {@code visitUnknown}
321 *
322 * @since 10
323 */
324 public R visitNoTypeAsModule(NoType t, P p) {
325 return visitUnknown(t, p);
326 }
327
328 /**
329 * Visits a {@link TypeKind#NONE NONE} pseudo-type.
330 *
331 * @implSpec This implementation calls {@code defaultAction}.
332 *
333 * @param t the type to visit
334 * @param p a visitor-specified parameter
335 * @return the result of {@code defaultAction}
336 */
337 public R visitNoTypeAsNone(NoType t, P p) {
338 return defaultAction(t, p);
339 }
340 }