1 /*
2 * Copyright (c) 2005, 2011, 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.lang.model.element.*;
29 import static javax.lang.model.element.ElementKind.*;
30 import javax.annotation.processing.SupportedSourceVersion;
31 import static javax.lang.model.SourceVersion.*;
32 import javax.lang.model.SourceVersion;
33
34
35 /**
36 * A visitor of program elements based on their {@linkplain
37 * ElementKind kind} with default behavior appropriate for the {@link
38 * SourceVersion#RELEASE_6 RELEASE_6} source version. For {@linkplain
39 * Element elements} <tt><i>XYZ</i></tt> that may have more than one
40 * kind, the <tt>visit<i>XYZ</i></tt> methods in this class delegate
41 * to the <tt>visit<i>XYZKind</i></tt> method corresponding to the
42 * first argument's kind. The <tt>visit<i>XYZKind</i></tt> methods
43 * call {@link #defaultAction defaultAction}, passing their arguments
44 * to {@code defaultAction}'s corresponding parameters.
45 *
46 * <p> Methods in this class may be overridden subject to their
47 * general contract. Note that annotating methods in concrete
48 * subclasses with {@link java.lang.Override @Override} will help
49 * ensure that methods are overridden as intended.
50 *
51 * <p> <b>WARNING:</b> The {@code ElementVisitor} interface
52 * implemented by this class may have methods added to it or the
53 * {@code ElementKind} {@code enum} used in this case may have
54 * constants added to it in the future to accommodate new, currently
55 * unknown, language structures added to future versions of the
56 * Java™ programming language. Therefore, methods whose names
57 * begin with {@code "visit"} may be added to this class in the
58 * future; to avoid incompatibilities, classes which extend this class
59 * should not declare any instance methods with names beginning with
60 * {@code "visit"}.
61 *
62 * <p>When such a new visit method is added, the default
63 * implementation in this class will be to call the {@link
64 * #visitUnknown visitUnknown} method. A new abstract element kind
65 * visitor class will also be introduced to correspond to the new
66 * language level; this visitor will have different default behavior
67 * for the visit method in question. When the new visitor is
68 * introduced, all or portions of this visitor may be deprecated.
69 *
70 * @param <R> the return type of this visitor's methods. Use {@link
71 * Void} for visitors that do not need to return results.
72 * @param <P> the type of the additional parameter to this visitor's
73 * methods. Use {@code Void} for visitors that do not need an
74 * additional parameter.
75 *
76 * @author Joseph D. Darcy
77 * @author Scott Seligman
78 * @author Peter von der Ahé
79 *
80 * @see ElementKindVisitor7
81 * @see ElementKindVisitor8
82 * @since 1.6
83 */
84 @SupportedSourceVersion(RELEASE_6)
85 public class ElementKindVisitor6<R, P>
86 extends SimpleElementVisitor6<R, P> {
87 /**
88 * Constructor for concrete subclasses; uses {@code null} for the
89 * default value.
90 */
91 protected ElementKindVisitor6() {
92 super(null);
93 }
94
95 /**
96 * Constructor for concrete subclasses; uses the argument for the
97 * default value.
98 *
99 * @param defaultValue the value to assign to {@link #DEFAULT_VALUE}
100 */
101 protected ElementKindVisitor6(R defaultValue) {
102 super(defaultValue);
103 }
104
105 /**
106 * {@inheritDoc}
107 *
108 * The element argument has kind {@code PACKAGE}.
109 *
110 * @param e {@inheritDoc}
111 * @param p {@inheritDoc}
112 * @return {@inheritDoc}
113 */
114 @Override
115 public R visitPackage(PackageElement e, P p) {
116 assert e.getKind() == PACKAGE: "Bad kind on PackageElement";
117 return defaultAction(e, p);
118 }
119
120 /**
121 * Visits a type element, dispatching to the visit method for the
122 * specific {@linkplain ElementKind kind} of type, {@code
123 * ANNOTATION_TYPE}, {@code CLASS}, {@code ENUM}, or {@code
124 * INTERFACE}.
125 *
126 * @param e {@inheritDoc}
127 * @param p {@inheritDoc}
128 * @return the result of the kind-specific visit method
129 */
130 @Override
131 public R visitType(TypeElement e, P p) {
132 ElementKind k = e.getKind();
133 switch(k) {
134 case ANNOTATION_TYPE:
135 return visitTypeAsAnnotationType(e, p);
136
137 case CLASS:
138 return visitTypeAsClass(e, p);
139
140 case ENUM:
141 return visitTypeAsEnum(e, p);
142
143 case INTERFACE:
144 return visitTypeAsInterface(e, p);
145
146 default:
147 throw new AssertionError("Bad kind " + k + " for TypeElement" + e);
148 }
149 }
150
151 /**
152 * Visits an {@code ANNOTATION_TYPE} type element by calling
153 * {@code defaultAction}.
154 *
155 * @param e the element to visit
156 * @param p a visitor-specified parameter
157 * @return the result of {@code defaultAction}
158 */
159 public R visitTypeAsAnnotationType(TypeElement e, P p) {
160 return defaultAction(e, p);
161 }
162
163 /**
164 * Visits a {@code CLASS} type element by calling {@code
165 * defaultAction}.
166 *
167 * @param e the element to visit
168 * @param p a visitor-specified parameter
169 * @return the result of {@code defaultAction}
170 */
171 public R visitTypeAsClass(TypeElement e, P p) {
172 return defaultAction(e, p);
173 }
174
175 /**
176 * Visits an {@code ENUM} type element by calling {@code
177 * defaultAction}.
178 *
179 * @param e the element to visit
180 * @param p a visitor-specified parameter
181 * @return the result of {@code defaultAction}
182 */
183 public R visitTypeAsEnum(TypeElement e, P p) {
184 return defaultAction(e, p);
185 }
186
187 /**
188 * Visits an {@code INTERFACE} type element by calling {@code
189 * defaultAction}.
190 *.
191 * @param e the element to visit
192 * @param p a visitor-specified parameter
193 * @return the result of {@code defaultAction}
194 */
195 public R visitTypeAsInterface(TypeElement e, P p) {
196 return defaultAction(e, p);
197 }
198
199 /**
200 * Visits a variable element, dispatching to the visit method for
201 * the specific {@linkplain ElementKind kind} of variable, {@code
202 * ENUM_CONSTANT}, {@code EXCEPTION_PARAMETER}, {@code FIELD},
203 * {@code LOCAL_VARIABLE}, {@code PARAMETER}, or {@code RESOURCE_VARIABLE}.
204 *
205 * @param e {@inheritDoc}
206 * @param p {@inheritDoc}
207 * @return the result of the kind-specific visit method
208 */
209 @Override
210 public R visitVariable(VariableElement e, P p) {
211 ElementKind k = e.getKind();
212 switch(k) {
213 case ENUM_CONSTANT:
214 return visitVariableAsEnumConstant(e, p);
215
216 case EXCEPTION_PARAMETER:
217 return visitVariableAsExceptionParameter(e, p);
218
219 case FIELD:
220 return visitVariableAsField(e, p);
221
222 case LOCAL_VARIABLE:
223 return visitVariableAsLocalVariable(e, p);
224
225 case PARAMETER:
226 return visitVariableAsParameter(e, p);
227
228 case RESOURCE_VARIABLE:
229 return visitVariableAsResourceVariable(e, p);
230
231 default:
232 throw new AssertionError("Bad kind " + k + " for VariableElement" + e);
233 }
234 }
235
236 /**
237 * Visits an {@code ENUM_CONSTANT} variable element by calling
238 * {@code defaultAction}.
239 *
240 * @param e the element to visit
241 * @param p a visitor-specified parameter
242 * @return the result of {@code defaultAction}
243 */
244 public R visitVariableAsEnumConstant(VariableElement e, P p) {
245 return defaultAction(e, p);
246 }
247
248 /**
249 * Visits an {@code EXCEPTION_PARAMETER} variable element by calling
250 * {@code defaultAction}.
251 *
252 * @param e the element to visit
253 * @param p a visitor-specified parameter
254 * @return the result of {@code defaultAction}
255 */
256 public R visitVariableAsExceptionParameter(VariableElement e, P p) {
257 return defaultAction(e, p);
258 }
259
260 /**
261 * Visits a {@code FIELD} variable element by calling
262 * {@code defaultAction}.
263 *
264 * @param e the element to visit
265 * @param p a visitor-specified parameter
266 * @return the result of {@code defaultAction}
267 */
268 public R visitVariableAsField(VariableElement e, P p) {
269 return defaultAction(e, p);
270 }
271
272 /**
273 * Visits a {@code LOCAL_VARIABLE} variable element by calling
274 * {@code defaultAction}.
275 *
276 * @param e the element to visit
277 * @param p a visitor-specified parameter
278 * @return the result of {@code defaultAction}
279 */
280 public R visitVariableAsLocalVariable(VariableElement e, P p) {
281 return defaultAction(e, p);
282 }
283
284 /**
285 * Visits a {@code PARAMETER} variable element by calling
286 * {@code defaultAction}.
287 *
288 * @param e the element to visit
289 * @param p a visitor-specified parameter
290 * @return the result of {@code defaultAction}
291 */
292 public R visitVariableAsParameter(VariableElement e, P p) {
293 return defaultAction(e, p);
294 }
295
296 /**
297 * Visits a {@code RESOURCE_VARIABLE} variable element by calling
298 * {@code visitUnknown}.
299 *
300 * @param e the element to visit
301 * @param p a visitor-specified parameter
302 * @return the result of {@code visitUnknown}
303 *
304 * @since 1.7
305 */
306 public R visitVariableAsResourceVariable(VariableElement e, P p) {
307 return visitUnknown(e, p);
308 }
309
310 /**
311 * Visits an executable element, dispatching to the visit method
312 * for the specific {@linkplain ElementKind kind} of executable,
313 * {@code CONSTRUCTOR}, {@code INSTANCE_INIT}, {@code METHOD}, or
314 * {@code STATIC_INIT}.
315 *
316 * @param e {@inheritDoc}
317 * @param p {@inheritDoc}
318 * @return the result of the kind-specific visit method
319 */
320 @Override
321 public R visitExecutable(ExecutableElement e, P p) {
322 ElementKind k = e.getKind();
323 switch(k) {
324 case CONSTRUCTOR:
325 return visitExecutableAsConstructor(e, p);
326
327 case INSTANCE_INIT:
328 return visitExecutableAsInstanceInit(e, p);
329
330 case METHOD:
331 return visitExecutableAsMethod(e, p);
332
333 case STATIC_INIT:
334 return visitExecutableAsStaticInit(e, p);
335
336 default:
337 throw new AssertionError("Bad kind " + k + " for ExecutableElement" + e);
338 }
339 }
340
341 /**
342 * Visits a {@code CONSTRUCTOR} executable element by calling
343 * {@code defaultAction}.
344 *
345 * @param e the element to visit
346 * @param p a visitor-specified parameter
347 * @return the result of {@code defaultAction}
348 */
349 public R visitExecutableAsConstructor(ExecutableElement e, P p) {
350 return defaultAction(e, p);
351 }
352
353 /**
354 * Visits an {@code INSTANCE_INIT} executable element by calling
355 * {@code defaultAction}.
356 *
357 * @param e the element to visit
358 * @param p a visitor-specified parameter
359 * @return the result of {@code defaultAction}
360 */
361 public R visitExecutableAsInstanceInit(ExecutableElement e, P p) {
362 return defaultAction(e, p);
363 }
364
365 /**
366 * Visits a {@code METHOD} executable element by calling
367 * {@code defaultAction}.
368 *
369 * @param e the element to visit
370 * @param p a visitor-specified parameter
371 * @return the result of {@code defaultAction}
372 */
373 public R visitExecutableAsMethod(ExecutableElement e, P p) {
374 return defaultAction(e, p);
375 }
376
377 /**
378 * Visits a {@code STATIC_INIT} executable element by calling
379 * {@code defaultAction}.
380 *
381 * @param e the element to visit
382 * @param p a visitor-specified parameter
383 * @return the result of {@code defaultAction}
384 */
385 public R visitExecutableAsStaticInit(ExecutableElement e, P p) {
386 return defaultAction(e, p);
387 }
388
389
390 /**
391 * {@inheritDoc}
392 *
393 * The element argument has kind {@code TYPE_PARAMETER}.
394 *
395 * @param e {@inheritDoc}
396 * @param p {@inheritDoc}
397 * @return {@inheritDoc}
398 */
399 @Override
400 public R visitTypeParameter(TypeParameterElement e, P p) {
401 assert e.getKind() == TYPE_PARAMETER: "Bad kind on TypeParameterElement";
402 return defaultAction(e, p);
403 }
404 }