1 /*
2 * Copyright (c) 2005, 2021, 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.source.tree;
27
28 import jdk.internal.javac.PreviewFeature;
29
30 /**
31 * A visitor of trees, in the style of the visitor design pattern.
32 * Classes implementing this interface are used to operate
33 * on a tree when the kind of tree is unknown at compile time.
34 * When a visitor is passed to a tree's {@link Tree#accept
35 * accept} method, the <code>visit<i>Xyz</i></code> method most applicable
36 * to that tree is invoked.
37 *
38 * <p> Classes implementing this interface may or may not throw a
39 * {@code NullPointerException} if the additional parameter {@code p}
40 * is {@code null}; see documentation of the implementing class for
41 * details.
42 *
43 * <p> <b>WARNING:</b> It is possible that methods will be added to
44 * this interface to accommodate new, currently unknown, language
45 * structures added to future versions of the Java programming
46 * language. Therefore, visitor classes directly implementing this
47 * interface may be source incompatible with future versions of the
48 * platform.
49 *
50 * @param <R> the return type of this visitor's methods. Use {@link
51 * Void} for visitors that do not need to return results.
52 * @param <P> the type of the additional parameter to this visitor's
53 * methods. Use {@code Void} for visitors that do not need an
54 * additional parameter.
55 *
56 * @author Peter von der Ahé
57 * @author Jonathan Gibbons
58 *
59 * @since 1.6
60 */
61 public interface TreeVisitor<R,P> {
62 /**
63 * Visits an {@code AnnotatedTypeTree} node.
64 * @param node the node being visited
65 * @param p a parameter value
66 * @return a result value
67 */
68 R visitAnnotatedType(AnnotatedTypeTree node, P p);
69
70 /**
71 * Visits an {@code AnnotatedTree} node.
72 * @param node the node being visited
73 * @param p a parameter value
74 * @return a result value
75 */
76 R visitAnnotation(AnnotationTree node, P p);
77
78 /**
79 * Visits a {@code MethodInvocationTree} node.
80 * @param node the node being visited
81 * @param p a parameter value
82 * @return a result value
83 */
84 R visitMethodInvocation(MethodInvocationTree node, P p);
85
86 /**
87 * Visits an {@code AssertTree} node.
88 * @param node the node being visited
89 * @param p a parameter value
90 * @return a result value
91 */
92 R visitAssert(AssertTree node, P p);
93
94 /**
95 * Visits an {@code AssignmentTree} node.
96 * @param node the node being visited
97 * @param p a parameter value
98 * @return a result value
99 */
100 R visitAssignment(AssignmentTree node, P p);
101
102 /**
103 * Visits a {@code CompoundAssignmentTree} node.
104 * @param node the node being visited
105 * @param p a parameter value
106 * @return a result value
107 */
108 R visitCompoundAssignment(CompoundAssignmentTree node, P p);
109
110 /**
111 * Visits a {@code BinaryTree} node.
112 * @param node the node being visited
113 * @param p a parameter value
114 * @return a result value
115 */
116 R visitBinary(BinaryTree node, P p);
117
118 /**
119 * Visits a {@code BlockTree} node.
120 * @param node the node being visited
121 * @param p a parameter value
122 * @return a result value
123 */
124 R visitBlock(BlockTree node, P p);
125
126 /**
127 * Visits a {@code BreakTree} node.
128 * @param node the node being visited
129 * @param p a parameter value
130 * @return a result value
131 */
132 R visitBreak(BreakTree node, P p);
133
134 /**
135 * Visits a {@code CaseTree} node.
136 * @param node the node being visited
137 * @param p a parameter value
138 * @return a result value
139 */
140 R visitCase(CaseTree node, P p);
141
142 /**
143 * Visits a {@code CatchTree} node.
144 * @param node the node being visited
145 * @param p a parameter value
146 * @return a result value
147 */
148 R visitCatch(CatchTree node, P p);
149
150 /**
151 * Visits a {@code ClassTree} node.
152 * @param node the node being visited
153 * @param p a parameter value
154 * @return a result value
155 */
156 R visitClass(ClassTree node, P p);
157
158 /**
159 * Visits a {@code ConditionalExpressionTree} node.
160 * @param node the node being visited
161 * @param p a parameter value
162 * @return a result value
163 */
164 R visitConditionalExpression(ConditionalExpressionTree node, P p);
165
166 /**
167 * Visits a {@code ContinueTree} node.
168 * @param node the node being visited
169 * @param p a parameter value
170 * @return a result value
171 */
172 R visitContinue(ContinueTree node, P p);
173
174 /**
175 * Visits a {@code DoWhileTree} node.
176 * @param node the node being visited
177 * @param p a parameter value
178 * @return a result value
179 */
180 R visitDoWhileLoop(DoWhileLoopTree node, P p);
181
182 /**
183 * Visits an {@code ErroneousTree} node.
184 * @param node the node being visited
185 * @param p a parameter value
186 * @return a result value
187 */
188 R visitErroneous(ErroneousTree node, P p);
189
190 /**
191 * Visits an {@code ExpressionStatementTree} node.
192 * @param node the node being visited
193 * @param p a parameter value
194 * @return a result value
195 */
196 R visitExpressionStatement(ExpressionStatementTree node, P p);
197
198 /**
199 * Visits an {@code EnhancedForLoopTree} node.
200 * @param node the node being visited
201 * @param p a parameter value
202 * @return a result value
203 */
204 R visitEnhancedForLoop(EnhancedForLoopTree node, P p);
205
206 /**
207 * Visits a {@code ForLoopTree} node.
208 * @param node the node being visited
209 * @param p a parameter value
210 * @return a result value
211 */
212 R visitForLoop(ForLoopTree node, P p);
213
214 /**
215 * Visits an {@code IdentifierTree} node.
216 * @param node the node being visited
217 * @param p a parameter value
218 * @return a result value
219 */
220 R visitIdentifier(IdentifierTree node, P p);
221
222 /**
223 * Visits an {@code IfTree} node.
224 * @param node the node being visited
225 * @param p a parameter value
226 * @return a result value
227 */
228 R visitIf(IfTree node, P p);
229
230 /**
231 * Visits an {@code ImportTree} node.
232 * @param node the node being visited
233 * @param p a parameter value
234 * @return a result value
235 */
236 R visitImport(ImportTree node, P p);
237
238 /**
239 * Visits an {@code ArrayAccessTree} node.
240 * @param node the node being visited
241 * @param p a parameter value
242 * @return a result value
243 */
244 R visitArrayAccess(ArrayAccessTree node, P p);
245
246 /**
247 * Visits a {@code LabeledStatementTree} node.
248 * @param node the node being visited
249 * @param p a parameter value
250 * @return a result value
251 */
252 R visitLabeledStatement(LabeledStatementTree node, P p);
253
254 /**
255 * Visits a {@code LiteralTree} node.
256 * @param node the node being visited
257 * @param p a parameter value
258 * @return a result value
259 */
260 R visitLiteral(LiteralTree node, P p);
261
262 /**
263 * Visits a {@code BindingPatternTree} node.
264 * @param node the node being visited
265 * @param p a parameter value
266 * @return a result value
267 * @since 16
268 */
269 R visitBindingPattern(BindingPatternTree node, P p);
270
271 /**
272 * Visits a {@code DefaultCaseLabelTree} node.
273 * @param node the node being visited
274 * @param p a parameter value
275 * @return a result value
276 * @since 17
277 */
278 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true)
279 R visitDefaultCaseLabel(DefaultCaseLabelTree node, P p);
280
281 /**
282 * Visits a {@code MethodTree} node.
283 * @param node the node being visited
284 * @param p a parameter value
285 * @return a result value
286 */
287 R visitMethod(MethodTree node, P p);
288
289 /**
290 * Visits a {@code ModifiersTree} node.
291 * @param node the node being visited
292 * @param p a parameter value
293 * @return a result value
294 */
295 R visitModifiers(ModifiersTree node, P p);
296
297 /**
298 * Visits a {@code NewArrayTree} node.
299 * @param node the node being visited
300 * @param p a parameter value
301 * @return a result value
302 */
303 R visitNewArray(NewArrayTree node, P p);
304
305 /**
306 * Visits a {@code GuardPatternTree} node.
307 * @param node the node being visited
308 * @param p a parameter value
309 * @return a result value
310 * @since 17
311 */
312 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true)
313 R visitGuardedPattern(GuardedPatternTree node, P p);
314
315 /**
316 * Visits a {@code ParenthesizedPatternTree} node.
317 * @param node the node being visited
318 * @param p a parameter value
319 * @return a result value
320 * @since 17
321 */
322 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true)
323 R visitParenthesizedPattern(ParenthesizedPatternTree node, P p);
324
325 /**
326 * Visits a {@code NewClassTree} node.
327 * @param node the node being visited
328 * @param p a parameter value
329 * @return a result value
330 */
331 R visitNewClass(NewClassTree node, P p);
332
333 /**
334 * Visits a {@code LambdaExpressionTree} node.
335 * @param node the node being visited
336 * @param p a parameter value
337 * @return a result value
338 */
339 R visitLambdaExpression(LambdaExpressionTree node, P p);
340
341 /**
342 * Visits a {@code PackageTree} node.
343 * @param node the node being visited
344 * @param p a parameter value
345 * @return a result value
346 */
347 R visitPackage(PackageTree node, P p);
348
349 /**
350 * Visits a {@code ParenthesizedTree} node.
351 * @param node the node being visited
352 * @param p a parameter value
353 * @return a result value
354 */
355 R visitParenthesized(ParenthesizedTree node, P p);
356
357 /**
358 * Visits a {@code ReturnTree} node.
359 * @param node the node being visited
360 * @param p a parameter value
361 * @return a result value
362 */
363 R visitReturn(ReturnTree node, P p);
364
365 /**
366 * Visits a {@code MemberSelectTree} node.
367 * @param node the node being visited
368 * @param p a parameter value
369 * @return a result value
370 */
371 R visitMemberSelect(MemberSelectTree node, P p);
372
373 /**
374 * Visits a {@code MemberReferenceTree} node.
375 * @param node the node being visited
376 * @param p a parameter value
377 * @return a result value
378 */
379 R visitMemberReference(MemberReferenceTree node, P p);
380
381 /**
382 * Visits an {@code EmptyStatementTree} node.
383 * @param node the node being visited
384 * @param p a parameter value
385 * @return a result value
386 */
387 R visitEmptyStatement(EmptyStatementTree node, P p);
388
389 /**
390 * Visits a {@code SwitchTree} node.
391 * @param node the node being visited
392 * @param p a parameter value
393 * @return a result value
394 */
395 R visitSwitch(SwitchTree node, P p);
396
397 /**
398 * Visits a {@code SwitchExpressionTree} node.
399 *
400 * @param node the node being visited
401 * @param p a parameter value
402 * @return a result value
403 * @since 12
404 */
405 R visitSwitchExpression(SwitchExpressionTree node, P p);
406
407 /**
408 * Visits a {@code SynchronizedTree} node.
409 * @param node the node being visited
410 * @param p a parameter value
411 * @return a result value
412 */
413 R visitSynchronized(SynchronizedTree node, P p);
414
415 /**
416 * Visits a {@code ThrowTree} node.
417 * @param node the node being visited
418 * @param p a parameter value
419 * @return a result value
420 */
421 R visitThrow(ThrowTree node, P p);
422
423 /**
424 * Visits a {@code CompilationUnitTree} node.
425 * @param node the node being visited
426 * @param p a parameter value
427 * @return a result value
428 */
429 R visitCompilationUnit(CompilationUnitTree node, P p);
430
431 /**
432 * Visits a {@code TryTree} node.
433 * @param node the node being visited
434 * @param p a parameter value
435 * @return a result value
436 */
437 R visitTry(TryTree node, P p);
438
439 /**
440 * Visits a {@code ParameterizedTypeTree} node.
441 * @param node the node being visited
442 * @param p a parameter value
443 * @return a result value
444 */
445 R visitParameterizedType(ParameterizedTypeTree node, P p);
446
447 /**
448 * Visits a {@code UnionTypeTree} node.
449 * @param node the node being visited
450 * @param p a parameter value
451 * @return a result value
452 */
453 R visitUnionType(UnionTypeTree node, P p);
454
455 /**
456 * Visits an {@code IntersectionTypeTree} node.
457 * @param node the node being visited
458 * @param p a parameter value
459 * @return a result value
460 */
461 R visitIntersectionType(IntersectionTypeTree node, P p);
462
463 /**
464 * Visits an {@code ArrayTypeTree} node.
465 * @param node the node being visited
466 * @param p a parameter value
467 * @return a result value
468 */
469 R visitArrayType(ArrayTypeTree node, P p);
470
471 /**
472 * Visits a {@code TypeCastTree} node.
473 * @param node the node being visited
474 * @param p a parameter value
475 * @return a result value
476 */
477 R visitTypeCast(TypeCastTree node, P p);
478
479 /**
480 * Visits a {@code PrimitiveTypeTree} node.
481 * @param node the node being visited
482 * @param p a parameter value
483 * @return a result value
484 */
485 R visitPrimitiveType(PrimitiveTypeTree node, P p);
486
487 /**
488 * Visits a {@code TypeParameterTree} node.
489 * @param node the node being visited
490 * @param p a parameter value
491 * @return a result value
492 */
493 R visitTypeParameter(TypeParameterTree node, P p);
494
495 /**
496 * Visits an {@code InstanceOfTree} node.
497 * @param node the node being visited
498 * @param p a parameter value
499 * @return a result value
500 */
501 R visitInstanceOf(InstanceOfTree node, P p);
502
503 /**
504 * Visits a {@code UnaryTree} node.
505 * @param node the node being visited
506 * @param p a parameter value
507 * @return a result value
508 */
509 R visitUnary(UnaryTree node, P p);
510
511 /**
512 * Visits a {@code VariableTree} node.
513 * @param node the node being visited
514 * @param p a parameter value
515 * @return a result value
516 */
517 R visitVariable(VariableTree node, P p);
518
519 /**
520 * Visits a {@code WhileLoopTree} node.
521 * @param node the node being visited
522 * @param p a parameter value
523 * @return a result value
524 */
525 R visitWhileLoop(WhileLoopTree node, P p);
526
527 /**
528 * Visits a {@code WildcardTypeTree} node.
529 * @param node the node being visited
530 * @param p a parameter value
531 * @return a result value
532 */
533 R visitWildcard(WildcardTree node, P p);
534
535 /**
536 * Visits a {@code ModuleTree} node.
537 * @param node the node being visited
538 * @param p a parameter value
539 * @return a result value
540 */
541 R visitModule(ModuleTree node, P p);
542
543 /**
544 * Visits an {@code ExportsTree} node.
545 * @param node the node being visited
546 * @param p a parameter value
547 * @return a result value
548 */
549 R visitExports(ExportsTree node, P p);
550
551 /**
552 * Visits an {@code OpensTree} node.
553 * @param node the node being visited
554 * @param p a parameter value
555 * @return a result value
556 */
557 R visitOpens(OpensTree node, P p);
558
559 /**
560 * Visits a {@code ProvidesTree} node.
561 * @param node the node being visited
562 * @param p a parameter value
563 * @return a result value
564 */
565 R visitProvides(ProvidesTree node, P p);
566
567 /**
568 * Visits a {@code RequiresTree} node.
569 * @param node the node being visited
570 * @param p a parameter value
571 * @return a result value
572 */
573 R visitRequires(RequiresTree node, P p);
574
575 /**
576 * Visits a {@code UsesTree} node.
577 * @param node the node being visited
578 * @param p a parameter value
579 * @return a result value
580 */
581 R visitUses(UsesTree node, P p);
582
583 /**
584 * Visits an unknown type of {@code Tree} node.
585 * This can occur if the language evolves and new kinds
586 * of nodes are added to the {@code Tree} hierarchy.
587 * @param node the node being visited
588 * @param p a parameter value
589 * @return a result value
590 */
591 R visitOther(Tree node, P p);
592
593 /**
594 * Visits a {@code YieldTree} node.
595 * @param node the node being visited
596 * @param p a parameter value
597 * @return a result value
598 * @since 13
599 */
600 R visitYield(YieldTree node, P p);
601 }