1 /*
2 * Copyright (c) 2005, 2022, 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.util;
27
28 import com.sun.source.tree.*;
29 import jdk.internal.javac.PreviewFeature;
30
31 /**
32 * A TreeVisitor that visits all the child tree nodes.
33 * To visit nodes of a particular type, just override the
34 * corresponding visitXYZ method.
35 * Inside your method, call super.visitXYZ to visit descendant
36 * nodes.
37 *
38 * <p>Here is an example to count the number of identifier nodes in a tree:
39 * <pre>
40 * class CountIdentifiers extends TreeScanner<Integer,Void> {
41 * {@literal @}Override
42 * public Integer visitIdentifier(IdentifierTree node, Void p) {
43 * return 1;
44 * }
45 * {@literal @}Override
46 * public Integer reduce(Integer r1, Integer r2) {
47 * return (r1 == null ? 0 : r1) + (r2 == null ? 0 : r2);
48 * }
49 * }
50 * </pre>
51 *
52 * @implSpec
53 * <p>The default implementation of the visitXYZ methods will determine
54 * a result as follows:
55 * <ul>
56 * <li>If the node being visited has no children, the result will be {@code null}.
57 * <li>If the node being visited has one child, the result will be the
58 * result of calling {@code scan} with that child. The child may be a simple node
59 * or itself a list of nodes.
60 * <li>If the node being visited has more than one child, the result will
61 * be determined by calling {@code scan} with each child in turn, and then combining the
62 * result of each scan after the first with the cumulative result
63 * so far, as determined by the {@link #reduce} method. Each child may be either
64 * a simple node or a list of nodes. The default behavior of the {@code reduce}
65 * method is such that the result of the visitXYZ method will be the result of
66 * the last child scanned.
67 * </ul>
68 *
69 * @param <R> the return type of this visitor's methods. Use {@link
70 * Void} for visitors that do not need to return results.
71 * @param <P> the type of the additional parameter to this visitor's
72 * methods. Use {@code Void} for visitors that do not need an
73 * additional parameter.
74 *
75 * @author Peter von der Ahé
76 * @author Jonathan Gibbons
77 * @since 1.6
78 */
79 public class TreeScanner<R,P> implements TreeVisitor<R,P> {
80 /**
81 * Constructs a {@code TreeScanner}.
82 */
83 public TreeScanner() {}
84
85 /**
86 * Scans a single node.
87 * @param tree the node to be scanned
88 * @param p a parameter value passed to the visit method
89 * @return the result value from the visit method
90 */
91 public R scan(Tree tree, P p) {
92 return (tree == null) ? null : tree.accept(this, p);
93 }
94
95 private R scanAndReduce(Tree node, P p, R r) {
96 return reduce(scan(node, p), r);
97 }
98
99 /**
100 * Scans a sequence of nodes.
101 * @param nodes the nodes to be scanned
102 * @param p a parameter value to be passed to the visit method for each node
103 * @return the combined return value from the visit methods.
104 * The values are combined using the {@link #reduce reduce} method.
105 */
106 public R scan(Iterable<? extends Tree> nodes, P p) {
107 R r = null;
108 if (nodes != null) {
109 boolean first = true;
110 for (Tree node : nodes) {
111 r = (first ? scan(node, p) : scanAndReduce(node, p, r));
112 first = false;
113 }
114 }
115 return r;
116 }
117
118 private R scanAndReduce(Iterable<? extends Tree> nodes, P p, R r) {
119 return reduce(scan(nodes, p), r);
120 }
121
122 /**
123 * Reduces two results into a combined result.
124 * The default implementation is to return the first parameter.
125 * The general contract of the method is that it may take any action whatsoever.
126 * @param r1 the first of the values to be combined
127 * @param r2 the second of the values to be combined
128 * @return the result of combining the two parameters
129 */
130 public R reduce(R r1, R r2) {
131 return r1;
132 }
133
134
135 /* ***************************************************************************
136 * Visitor methods
137 ****************************************************************************/
138
139 /**
140 * {@inheritDoc}
141 *
142 * @implSpec This implementation scans the children in left to right order.
143 *
144 * @param node {@inheritDoc}
145 * @param p {@inheritDoc}
146 * @return the result of scanning
147 */
148 @Override
149 public R visitCompilationUnit(CompilationUnitTree node, P p) {
150 R r = scan(node.getPackage(), p);
151 r = scanAndReduce(node.getImports(), p, r);
152 r = scanAndReduce(node.getTypeDecls(), p, r);
153 r = scanAndReduce(node.getModule(), p, r);
154 return r;
155 }
156
157 /**
158 * {@inheritDoc}
159 *
160 * @implSpec This implementation scans the children in left to right order.
161 *
162 * @param node {@inheritDoc}
163 * @param p {@inheritDoc}
164 * @return the result of scanning
165 */
166 @Override
167 public R visitPackage(PackageTree node, P p) {
168 R r = scan(node.getAnnotations(), p);
169 r = scanAndReduce(node.getPackageName(), p, r);
170 return r;
171 }
172
173 /**
174 * {@inheritDoc}
175 *
176 * @implSpec This implementation scans the children in left to right order.
177 *
178 * @param node {@inheritDoc}
179 * @param p {@inheritDoc}
180 * @return the result of scanning
181 */
182 @Override
183 public R visitImport(ImportTree node, P p) {
184 return scan(node.getQualifiedIdentifier(), p);
185 }
186
187 /**
188 * {@inheritDoc}
189 *
190 * @implSpec This implementation scans the children in left to right order.
191 *
192 * @param node {@inheritDoc}
193 * @param p {@inheritDoc}
194 * @return the result of scanning
195 */
196 @Override
197 public R visitClass(ClassTree node, P p) {
198 R r = scan(node.getModifiers(), p);
199 r = scanAndReduce(node.getTypeParameters(), p, r);
200 r = scanAndReduce(node.getExtendsClause(), p, r);
201 r = scanAndReduce(node.getImplementsClause(), p, r);
202 r = scanAndReduce(node.getPermitsClause(), p, r);
203 r = scanAndReduce(node.getMembers(), p, r);
204 return r;
205 }
206
207 /**
208 * {@inheritDoc}
209 *
210 * @implSpec This implementation scans the children in left to right order.
211 *
212 * @param node {@inheritDoc}
213 * @param p {@inheritDoc}
214 * @return the result of scanning
215 */
216 @Override
217 public R visitMethod(MethodTree node, P p) {
218 R r = scan(node.getModifiers(), p);
219 r = scanAndReduce(node.getReturnType(), p, r);
220 r = scanAndReduce(node.getTypeParameters(), p, r);
221 r = scanAndReduce(node.getParameters(), p, r);
222 r = scanAndReduce(node.getReceiverParameter(), p, r);
223 r = scanAndReduce(node.getThrows(), p, r);
224 r = scanAndReduce(node.getBody(), p, r);
225 r = scanAndReduce(node.getDefaultValue(), p, r);
226 return r;
227 }
228
229 /**
230 * {@inheritDoc}
231 *
232 * @implSpec This implementation scans the children in left to right order.
233 *
234 * @param node {@inheritDoc}
235 * @param p {@inheritDoc}
236 * @return the result of scanning
237 */
238 @Override
239 public R visitVariable(VariableTree node, P p) {
240 R r = scan(node.getModifiers(), p);
241 r = scanAndReduce(node.getType(), p, r);
242 r = scanAndReduce(node.getNameExpression(), p, r);
243 r = scanAndReduce(node.getInitializer(), p, r);
244 return r;
245 }
246
247 /**
248 * {@inheritDoc}
249 *
250 * @implSpec This implementation returns {@code null}.
251 *
252 * @param node {@inheritDoc}
253 * @param p {@inheritDoc}
254 * @return the result of scanning
255 */
256 @Override
257 public R visitEmptyStatement(EmptyStatementTree node, P p) {
258 return null;
259 }
260
261 /**
262 * {@inheritDoc}
263 *
264 * @implSpec This implementation scans the children in left to right order.
265 *
266 * @param node {@inheritDoc}
267 * @param p {@inheritDoc}
268 * @return the result of scanning
269 */
270 @Override
271 public R visitBlock(BlockTree node, P p) {
272 return scan(node.getStatements(), p);
273 }
274
275 /**
276 * {@inheritDoc}
277 *
278 * @implSpec This implementation scans the children in left to right order.
279 *
280 * @param node {@inheritDoc}
281 * @param p {@inheritDoc}
282 * @return the result of scanning
283 */
284 @Override
285 public R visitDoWhileLoop(DoWhileLoopTree node, P p) {
286 R r = scan(node.getStatement(), p);
287 r = scanAndReduce(node.getCondition(), p, r);
288 return r;
289 }
290
291 /**
292 * {@inheritDoc}
293 *
294 * @implSpec This implementation scans the children in left to right order.
295 *
296 * @param node {@inheritDoc}
297 * @param p {@inheritDoc}
298 * @return the result of scanning
299 */
300 @Override
301 public R visitWhileLoop(WhileLoopTree node, P p) {
302 R r = scan(node.getCondition(), p);
303 r = scanAndReduce(node.getStatement(), p, r);
304 return r;
305 }
306
307 /**
308 * {@inheritDoc} This implementation scans the children in left to right order.
309 *
310 * @param node {@inheritDoc}
311 * @param p {@inheritDoc}
312 * @return the result of scanning
313 */
314 @Override
315 public R visitForLoop(ForLoopTree node, P p) {
316 R r = scan(node.getInitializer(), p);
317 r = scanAndReduce(node.getCondition(), p, r);
318 r = scanAndReduce(node.getUpdate(), p, r);
319 r = scanAndReduce(node.getStatement(), p, r);
320 return r;
321 }
322
323 /**
324 * {@inheritDoc}
325 *
326 * @implSpec This implementation scans the children in left to right order.
327 *
328 * @param node {@inheritDoc}
329 * @param p {@inheritDoc}
330 * @return the result of scanning
331 */
332 @Override
333 public R visitEnhancedForLoop(EnhancedForLoopTree node, P p) {
334 R r = scan(node.getVariable(), p);
335 r = scanAndReduce(node.getExpression(), p, r);
336 r = scanAndReduce(node.getStatement(), p, r);
337 return r;
338 }
339
340 /**
341 * {@inheritDoc}
342 *
343 * @implSpec This implementation scans the children in left to right order.
344 *
345 * @param node {@inheritDoc}
346 * @param p {@inheritDoc}
347 * @return the result of scanning
348 */
349 @Override
350 public R visitLabeledStatement(LabeledStatementTree node, P p) {
351 return scan(node.getStatement(), p);
352 }
353
354 /**
355 * {@inheritDoc}
356 *
357 * @implSpec This implementation scans the children in left to right order.
358 *
359 * @param node {@inheritDoc}
360 * @param p {@inheritDoc}
361 * @return the result of scanning
362 */
363 @Override
364 public R visitSwitch(SwitchTree node, P p) {
365 R r = scan(node.getExpression(), p);
366 r = scanAndReduce(node.getCases(), p, r);
367 return r;
368 }
369
370 /**
371 * {@inheritDoc}
372 *
373 * @implSpec This implementation scans the children in left to right order.
374 *
375 * @param node {@inheritDoc}
376 * @param p {@inheritDoc}
377 * @return the result of scanning
378 */
379 @Override
380 public R visitSwitchExpression(SwitchExpressionTree node, P p) {
381 R r = scan(node.getExpression(), p);
382 r = scanAndReduce(node.getCases(), p, r);
383 return r;
384 }
385
386 /**
387 * {@inheritDoc}
388 *
389 * @implSpec This implementation scans the children in left to right order.
390 *
391 * @param node {@inheritDoc}
392 * @param p {@inheritDoc}
393 * @return the result of scanning
394 */
395 @Override
396 public R visitCase(CaseTree node, P p) {
397 R r = scan(node.getLabels(), p);
398 r = scanAndReduce(node.getGuard(), p, r);
399 if (node.getCaseKind() == CaseTree.CaseKind.RULE)
400 r = scanAndReduce(node.getBody(), p, r);
401 else
402 r = scanAndReduce(node.getStatements(), p, r);
403 return r;
404 }
405
406 /**
407 * {@inheritDoc}
408 *
409 * @implSpec This implementation scans the children in left to right order.
410 *
411 * @param node {@inheritDoc}
412 * @param p {@inheritDoc}
413 * @return the result of scanning
414 */
415 @Override
416 public R visitSynchronized(SynchronizedTree node, P p) {
417 R r = scan(node.getExpression(), p);
418 r = scanAndReduce(node.getBlock(), p, r);
419 return r;
420 }
421
422 /**
423 * {@inheritDoc}
424 *
425 * @implSpec This implementation scans the children in left to right order.
426 *
427 * @param node {@inheritDoc}
428 * @param p {@inheritDoc}
429 * @return the result of scanning
430 */
431 @Override
432 public R visitTry(TryTree node, P p) {
433 R r = scan(node.getResources(), p);
434 r = scanAndReduce(node.getBlock(), p, r);
435 r = scanAndReduce(node.getCatches(), p, r);
436 r = scanAndReduce(node.getFinallyBlock(), p, r);
437 return r;
438 }
439
440 /**
441 * {@inheritDoc}
442 *
443 * @implSpec This implementation scans the children in left to right order.
444 *
445 * @param node {@inheritDoc}
446 * @param p {@inheritDoc}
447 * @return the result of scanning
448 */
449 @Override
450 public R visitCatch(CatchTree node, P p) {
451 R r = scan(node.getParameter(), p);
452 r = scanAndReduce(node.getBlock(), p, r);
453 return r;
454 }
455
456 /**
457 * {@inheritDoc}
458 *
459 * @implSpec This implementation scans the children in left to right order.
460 *
461 * @param node {@inheritDoc}
462 * @param p {@inheritDoc}
463 * @return the result of scanning
464 */
465 @Override
466 public R visitConditionalExpression(ConditionalExpressionTree node, P p) {
467 R r = scan(node.getCondition(), p);
468 r = scanAndReduce(node.getTrueExpression(), p, r);
469 r = scanAndReduce(node.getFalseExpression(), p, r);
470 return r;
471 }
472
473 /**
474 * {@inheritDoc}
475 *
476 * @implSpec This implementation scans the children in left to right order.
477 *
478 * @param node {@inheritDoc}
479 * @param p {@inheritDoc}
480 * @return the result of scanning
481 */
482 @Override
483 public R visitIf(IfTree node, P p) {
484 R r = scan(node.getCondition(), p);
485 r = scanAndReduce(node.getThenStatement(), p, r);
486 r = scanAndReduce(node.getElseStatement(), p, r);
487 return r;
488 }
489
490 /**
491 * {@inheritDoc}
492 *
493 * @implSpec This implementation scans the children in left to right order.
494 *
495 * @param node {@inheritDoc}
496 * @param p {@inheritDoc}
497 * @return the result of scanning
498 */
499 @Override
500 public R visitExpressionStatement(ExpressionStatementTree node, P p) {
501 return scan(node.getExpression(), p);
502 }
503
504 /**
505 * {@inheritDoc}
506 *
507 * @implSpec This implementation returns {@code null}.
508 *
509 * @param node {@inheritDoc}
510 * @param p {@inheritDoc}
511 * @return the result of scanning
512 */
513 @Override
514 public R visitBreak(BreakTree node, P p) {
515 return null;
516 }
517
518 /**
519 * {@inheritDoc}
520 *
521 * @implSpec This implementation returns {@code null}.
522 *
523 * @param node {@inheritDoc}
524 * @param p {@inheritDoc}
525 * @return the result of scanning
526 */
527 @Override
528 public R visitContinue(ContinueTree node, P p) {
529 return null;
530 }
531
532 /**
533 * {@inheritDoc}
534 *
535 * @implSpec This implementation scans the children in left to right order.
536 *
537 * @param node {@inheritDoc}
538 * @param p {@inheritDoc}
539 * @return the result of scanning
540 */
541 @Override
542 public R visitReturn(ReturnTree node, P p) {
543 return scan(node.getExpression(), p);
544 }
545
546 /**
547 * {@inheritDoc}
548 *
549 * @implSpec This implementation scans the children in left to right order.
550 *
551 * @param node {@inheritDoc}
552 * @param p {@inheritDoc}
553 * @return the result of scanning
554 */
555 @Override
556 public R visitThrow(ThrowTree node, P p) {
557 return scan(node.getExpression(), p);
558 }
559
560 /**
561 * {@inheritDoc}
562 *
563 * @implSpec This implementation scans the children in left to right order.
564 *
565 * @param node {@inheritDoc}
566 * @param p {@inheritDoc}
567 * @return the result of scanning
568 */
569 @Override
570 public R visitAssert(AssertTree node, P p) {
571 R r = scan(node.getCondition(), p);
572 r = scanAndReduce(node.getDetail(), p, r);
573 return r;
574 }
575
576 /**
577 * {@inheritDoc}
578 *
579 * @implSpec This implementation scans the children in left to right order.
580 *
581 * @param node {@inheritDoc}
582 * @param p {@inheritDoc}
583 * @return the result of scanning
584 */
585 @Override
586 public R visitMethodInvocation(MethodInvocationTree node, P p) {
587 R r = scan(node.getTypeArguments(), p);
588 r = scanAndReduce(node.getMethodSelect(), p, r);
589 r = scanAndReduce(node.getArguments(), p, r);
590 return r;
591 }
592
593 /**
594 * {@inheritDoc}
595 *
596 * @implSpec This implementation scans the children in left to right order.
597 *
598 * @param node {@inheritDoc}
599 * @param p {@inheritDoc}
600 * @return the result of scanning
601 */
602 @Override
603 public R visitNewClass(NewClassTree node, P p) {
604 R r = scan(node.getEnclosingExpression(), p);
605 r = scanAndReduce(node.getIdentifier(), p, r);
606 r = scanAndReduce(node.getTypeArguments(), p, r);
607 r = scanAndReduce(node.getArguments(), p, r);
608 r = scanAndReduce(node.getClassBody(), p, r);
609 return r;
610 }
611
612 /**
613 * {@inheritDoc}
614 *
615 * @implSpec This implementation scans the children in left to right order.
616 *
617 * @param node {@inheritDoc}
618 * @param p {@inheritDoc}
619 * @return the result of scanning
620 */
621 @Override
622 public R visitNewArray(NewArrayTree node, P p) {
623 R r = scan(node.getType(), p);
624 r = scanAndReduce(node.getDimensions(), p, r);
625 r = scanAndReduce(node.getInitializers(), p, r);
626 r = scanAndReduce(node.getAnnotations(), p, r);
627 for (Iterable< ? extends Tree> dimAnno : node.getDimAnnotations()) {
628 r = scanAndReduce(dimAnno, p, r);
629 }
630 return r;
631 }
632
633 /**
634 * {@inheritDoc}
635 *
636 * @implSpec This implementation scans the children in left to right order.
637 *
638 * @param node {@inheritDoc}
639 * @param p {@inheritDoc}
640 * @return the result of scanning
641 */
642 @Override
643 public R visitLambdaExpression(LambdaExpressionTree node, P p) {
644 R r = scan(node.getParameters(), p);
645 r = scanAndReduce(node.getBody(), p, r);
646 return r;
647 }
648
649 /**
650 * {@inheritDoc}
651 *
652 * @implSpec This implementation scans the children in left to right order.
653 *
654 * @param node {@inheritDoc}
655 * @param p {@inheritDoc}
656 * @return the result of scanning
657 */
658 @Override
659 public R visitParenthesized(ParenthesizedTree node, P p) {
660 return scan(node.getExpression(), p);
661 }
662
663 /**
664 * {@inheritDoc}
665 *
666 * @implSpec This implementation scans the children in left to right order.
667 *
668 * @param node {@inheritDoc}
669 * @param p {@inheritDoc}
670 * @return the result of scanning
671 */
672 @Override
673 public R visitAssignment(AssignmentTree node, P p) {
674 R r = scan(node.getVariable(), p);
675 r = scanAndReduce(node.getExpression(), p, r);
676 return r;
677 }
678
679 /**
680 * {@inheritDoc}
681 *
682 * @implSpec This implementation scans the children in left to right order.
683 *
684 * @param node {@inheritDoc}
685 * @param p {@inheritDoc}
686 * @return the result of scanning
687 */
688 @Override
689 public R visitCompoundAssignment(CompoundAssignmentTree node, P p) {
690 R r = scan(node.getVariable(), p);
691 r = scanAndReduce(node.getExpression(), p, r);
692 return r;
693 }
694
695 /**
696 * {@inheritDoc}
697 *
698 * @implSpec This implementation scans the children in left to right order.
699 *
700 * @param node {@inheritDoc}
701 * @param p {@inheritDoc}
702 * @return the result of scanning
703 */
704 @Override
705 public R visitUnary(UnaryTree node, P p) {
706 return scan(node.getExpression(), p);
707 }
708
709 /**
710 * {@inheritDoc}
711 *
712 * @implSpec This implementation scans the children in left to right order.
713 *
714 * @param node {@inheritDoc}
715 * @param p {@inheritDoc}
716 * @return the result of scanning
717 */
718 @Override
719 public R visitBinary(BinaryTree node, P p) {
720 R r = scan(node.getLeftOperand(), p);
721 r = scanAndReduce(node.getRightOperand(), p, r);
722 return r;
723 }
724
725 /**
726 * {@inheritDoc}
727 *
728 * @implSpec This implementation scans the children in left to right order.
729 *
730 * @param node {@inheritDoc}
731 * @param p {@inheritDoc}
732 * @return the result of scanning
733 */
734 @Override
735 public R visitTypeCast(TypeCastTree node, P p) {
736 R r = scan(node.getType(), p);
737 r = scanAndReduce(node.getExpression(), p, r);
738 return r;
739 }
740
741 /**
742 * {@inheritDoc}
743 *
744 * @implSpec This implementation scans the children in left to right order.
745 *
746 * @param node {@inheritDoc}
747 * @param p {@inheritDoc}
748 * @return the result of scanning
749 */
750 @Override
751 public R visitInstanceOf(InstanceOfTree node, P p) {
752 R r = scan(node.getExpression(), p);
753 if (node.getPattern() != null) {
754 r = scanAndReduce(node.getPattern(), p, r);
755 } else {
756 r = scanAndReduce(node.getType(), p, r);
757 }
758 return r;
759 }
760
761 /**
762 * {@inheritDoc}
763 *
764 * @implSpec This implementation returns {@code null}.
765 *
766 * @param node {@inheritDoc}
767 * @param p {@inheritDoc}
768 * @return the result of scanning
769 * @since 21
770 */
771 @Override
772 public R visitAnyPattern(AnyPatternTree node, P p) {
773 return null;
774 }
775
776 /**
777 * {@inheritDoc}
778 *
779 * @implSpec This implementation scans the children in left to right order.
780 *
781 * @param node {@inheritDoc}
782 * @param p {@inheritDoc}
783 * @return the result of scanning
784 * @since 21
785 */
786 @Override
787 @PreviewFeature(feature=PreviewFeature.Feature.STRING_TEMPLATES, reflective=true)
788 public R visitStringTemplate(StringTemplateTree node, P p) {
789 R r = scan(node.getProcessor(), p);
790 r = scanAndReduce(node.getExpressions(), p, r);
791 return r;
792 }
793
794 /**
795 * {@inheritDoc}
796 *
797 * @implSpec This implementation scans the children in left to right order.
798 *
799 * @param node {@inheritDoc}
800 * @param p {@inheritDoc}
801 * @return the result of scanning
802 * @since 14
803 */
804 @Override
805 public R visitBindingPattern(BindingPatternTree node, P p) {
806 return scan(node.getVariable(), p);
807 }
808
809 /**
810 * {@inheritDoc}
811 *
812 * @implSpec This implementation returns {@code null}.
813 *
814 * @param node {@inheritDoc}
815 * @param p {@inheritDoc}
816 * @return the result of scanning
817 * @since 21
818 */
819 @Override
820 public R visitDefaultCaseLabel(DefaultCaseLabelTree node, P p) {
821 return null;
822 }
823
824 /**
825 * {@inheritDoc}
826 *
827 * @implSpec This implementation returns {@code null}.
828 *
829 * @param node {@inheritDoc}
830 * @param p {@inheritDoc}
831 * @return the result of scanning
832 * @since 21
833 */
834 @Override
835 public R visitConstantCaseLabel(ConstantCaseLabelTree node, P p) {
836 return scan(node.getConstantExpression(), p);
837 }
838
839 /**
840 * {@inheritDoc}
841 *
842 * @implSpec This implementation returns {@code null}.
843 *
844 * @param node {@inheritDoc}
845 * @param p {@inheritDoc}
846 * @return the result of scanning
847 * @since 21
848 */
849 @Override
850 public R visitPatternCaseLabel(PatternCaseLabelTree node, P p) {
851 return scan(node.getPattern(), p);
852 }
853
854 /**
855 * {@inheritDoc}
856 *
857 * @implSpec This implementation scans the children in left to right order.
858 *
859 * @param node {@inheritDoc}
860 * @param p {@inheritDoc}
861 * @return the result of scanning
862 * @since 21
863 */
864 @Override
865 public R visitDeconstructionPattern(DeconstructionPatternTree node, P p) {
866 R r = scan(node.getDeconstructor(), p);
867 r = scanAndReduce(node.getNestedPatterns(), p, r);
868 return r;
869 }
870
871 /**
872 * {@inheritDoc} This implementation scans the children in left to right order.
873 *
874 * @param node {@inheritDoc}
875 * @param p {@inheritDoc}
876 * @return the result of scanning
877 */
878 @Override
879 public R visitArrayAccess(ArrayAccessTree node, P p) {
880 R r = scan(node.getExpression(), p);
881 r = scanAndReduce(node.getIndex(), p, r);
882 return r;
883 }
884
885 /**
886 * {@inheritDoc}
887 *
888 * @implSpec This implementation scans the children in left to right order.
889 *
890 * @param node {@inheritDoc}
891 * @param p {@inheritDoc}
892 * @return the result of scanning
893 */
894 @Override
895 public R visitMemberSelect(MemberSelectTree node, P p) {
896 return scan(node.getExpression(), p);
897 }
898
899 /**
900 * {@inheritDoc}
901 *
902 * @implSpec This implementation scans the children in left to right order.
903 *
904 * @param node {@inheritDoc}
905 * @param p {@inheritDoc}
906 * @return the result of scanning
907 */
908 @Override
909 public R visitMemberReference(MemberReferenceTree node, P p) {
910 R r = scan(node.getQualifierExpression(), p);
911 r = scanAndReduce(node.getTypeArguments(), p, r);
912 return r;
913 }
914
915 /**
916 * {@inheritDoc}
917 *
918 * @implSpec This implementation returns {@code null}.
919 *
920 * @param node {@inheritDoc}
921 * @param p {@inheritDoc}
922 * @return the result of scanning
923 */
924 @Override
925 public R visitIdentifier(IdentifierTree node, P p) {
926 return null;
927 }
928
929 /**
930 * {@inheritDoc}
931 *
932 * @implSpec This implementation returns {@code null}.
933 *
934 * @param node {@inheritDoc}
935 * @param p {@inheritDoc}
936 * @return the result of scanning
937 */
938 @Override
939 public R visitLiteral(LiteralTree node, P p) {
940 return null;
941 }
942
943 /**
944 * {@inheritDoc}
945 *
946 * @implSpec This implementation returns {@code null}.
947 *
948 * @param node {@inheritDoc}
949 * @param p {@inheritDoc}
950 * @return the result of scanning
951 */
952 @Override
953 public R visitPrimitiveType(PrimitiveTypeTree node, P p) {
954 return null;
955 }
956
957 /**
958 * {@inheritDoc}
959 *
960 * @implSpec This implementation scans the children in left to right order.
961 *
962 * @param node {@inheritDoc}
963 * @param p {@inheritDoc}
964 * @return the result of scanning
965 */
966 @Override
967 public R visitArrayType(ArrayTypeTree node, P p) {
968 return scan(node.getType(), p);
969 }
970
971 /**
972 * {@inheritDoc}
973 *
974 * @implSpec This implementation scans the children in left to right order.
975 *
976 * @param node {@inheritDoc}
977 * @param p {@inheritDoc}
978 * @return the result of scanning
979 */
980 @Override
981 public R visitParameterizedType(ParameterizedTypeTree node, P p) {
982 R r = scan(node.getType(), p);
983 r = scanAndReduce(node.getTypeArguments(), p, r);
984 return r;
985 }
986
987 /**
988 * {@inheritDoc}
989 *
990 * @implSpec This implementation scans the children in left to right order.
991 *
992 * @param node {@inheritDoc}
993 * @param p {@inheritDoc}
994 * @return the result of scanning
995 */
996 @Override
997 public R visitUnionType(UnionTypeTree node, P p) {
998 return scan(node.getTypeAlternatives(), p);
999 }
1000
1001 /**
1002 * {@inheritDoc}
1003 *
1004 * @implSpec This implementation scans the children in left to right order.
1005 *
1006 * @param node {@inheritDoc}
1007 * @param p {@inheritDoc}
1008 * @return the result of scanning
1009 */
1010 @Override
1011 public R visitIntersectionType(IntersectionTypeTree node, P p) {
1012 return scan(node.getBounds(), p);
1013 }
1014
1015 /**
1016 * {@inheritDoc}
1017 *
1018 * @implSpec This implementation scans the children in left to right order.
1019 *
1020 * @param node {@inheritDoc}
1021 * @param p {@inheritDoc}
1022 * @return the result of scanning
1023 */
1024 @Override
1025 public R visitTypeParameter(TypeParameterTree node, P p) {
1026 R r = scan(node.getAnnotations(), p);
1027 r = scanAndReduce(node.getBounds(), p, r);
1028 return r;
1029 }
1030
1031 /**
1032 * {@inheritDoc}
1033 *
1034 * @implSpec This implementation scans the children in left to right order.
1035 *
1036 * @param node {@inheritDoc}
1037 * @param p {@inheritDoc}
1038 * @return the result of scanning
1039 */
1040 @Override
1041 public R visitWildcard(WildcardTree node, P p) {
1042 return scan(node.getBound(), p);
1043 }
1044
1045 /**
1046 * {@inheritDoc}
1047 *
1048 * @implSpec This implementation scans the children in left to right order.
1049 *
1050 * @param node {@inheritDoc}
1051 * @param p {@inheritDoc}
1052 * @return the result of scanning
1053 */
1054 @Override
1055 public R visitModifiers(ModifiersTree node, P p) {
1056 return scan(node.getAnnotations(), p);
1057 }
1058
1059 /**
1060 * {@inheritDoc}
1061 *
1062 * @implSpec This implementation scans the children in left to right order.
1063 *
1064 * @param node {@inheritDoc}
1065 * @param p {@inheritDoc}
1066 * @return the result of scanning
1067 */
1068 @Override
1069 public R visitAnnotation(AnnotationTree node, P p) {
1070 R r = scan(node.getAnnotationType(), p);
1071 r = scanAndReduce(node.getArguments(), p, r);
1072 return r;
1073 }
1074
1075 /**
1076 * {@inheritDoc}
1077 *
1078 * @implSpec This implementation scans the children in left to right order.
1079 *
1080 * @param node {@inheritDoc}
1081 * @param p {@inheritDoc}
1082 * @return the result of scanning
1083 */
1084 @Override
1085 public R visitAnnotatedType(AnnotatedTypeTree node, P p) {
1086 R r = scan(node.getAnnotations(), p);
1087 r = scanAndReduce(node.getUnderlyingType(), p, r);
1088 return r;
1089 }
1090
1091 /**
1092 * {@inheritDoc}
1093 *
1094 * @implSpec This implementation scans the children in left to right order.
1095 *
1096 * @param node {@inheritDoc}
1097 * @param p {@inheritDoc}
1098 * @return the result of scanning
1099 */
1100 @Override
1101 public R visitModule(ModuleTree node, P p) {
1102 R r = scan(node.getAnnotations(), p);
1103 r = scanAndReduce(node.getName(), p, r);
1104 r = scanAndReduce(node.getDirectives(), p, r);
1105 return r;
1106 }
1107
1108 /**
1109 * {@inheritDoc}
1110 *
1111 * @implSpec This implementation scans the children in left to right order.
1112 *
1113 * @param node {@inheritDoc}
1114 * @param p {@inheritDoc}
1115 * @return the result of scanning
1116 */
1117 @Override
1118 public R visitExports(ExportsTree node, P p) {
1119 R r = scan(node.getPackageName(), p);
1120 r = scanAndReduce(node.getModuleNames(), p, r);
1121 return r;
1122 }
1123
1124 /**
1125 * {@inheritDoc}
1126 *
1127 * @implSpec This implementation scans the children in left to right order.
1128 *
1129 * @param node {@inheritDoc}
1130 * @param p {@inheritDoc}
1131 * @return the result of scanning
1132 */
1133 @Override
1134 public R visitOpens(OpensTree node, P p) {
1135 R r = scan(node.getPackageName(), p);
1136 r = scanAndReduce(node.getModuleNames(), p, r);
1137 return r;
1138 }
1139
1140 /**
1141 * {@inheritDoc}
1142 *
1143 * @implSpec This implementation scans the children in left to right order.
1144 *
1145 * @param node {@inheritDoc}
1146 * @param p {@inheritDoc}
1147 * @return the result of scanning
1148 */
1149 @Override
1150 public R visitProvides(ProvidesTree node, P p) {
1151 R r = scan(node.getServiceName(), p);
1152 r = scanAndReduce(node.getImplementationNames(), p, r);
1153 return r;
1154 }
1155
1156 /**
1157 * {@inheritDoc}
1158 *
1159 * @implSpec This implementation scans the children in left to right order.
1160 *
1161 * @param node {@inheritDoc}
1162 * @param p {@inheritDoc}
1163 * @return the result of scanning
1164 */
1165 @Override
1166 public R visitRequires(RequiresTree node, P p) {
1167 return scan(node.getModuleName(), p);
1168 }
1169
1170 /**
1171 * {@inheritDoc}
1172 *
1173 * @implSpec This implementation scans the children in left to right order.
1174 *
1175 * @param node {@inheritDoc}
1176 * @param p {@inheritDoc}
1177 * @return the result of scanning
1178 */
1179 @Override
1180 public R visitUses(UsesTree node, P p) {
1181 return scan(node.getServiceName(), p);
1182 }
1183
1184 /**
1185 * {@inheritDoc}
1186 *
1187 * @implSpec This implementation returns {@code null}.
1188 *
1189 * @param node {@inheritDoc}
1190 * @param p {@inheritDoc}
1191 * @return the result of scanning
1192 */
1193 @Override
1194 public R visitOther(Tree node, P p) {
1195 return null;
1196 }
1197
1198 /**
1199 * {@inheritDoc}
1200 *
1201 * @implSpec This implementation returns {@code null}.
1202 *
1203 * @param node {@inheritDoc}
1204 * @param p {@inheritDoc}
1205 * @return the result of scanning
1206 */
1207 @Override
1208 public R visitErroneous(ErroneousTree node, P p) {
1209 return null;
1210 }
1211
1212 /**
1213 * {@inheritDoc}
1214 *
1215 * @implSpec This implementation scans the children in left to right order.
1216 *
1217 * @param node {@inheritDoc}
1218 * @param p {@inheritDoc}
1219 * @return the result of scanning
1220 */
1221 @Override
1222 public R visitYield(YieldTree node, P p) {
1223 return scan(node.getValue(), p);
1224 }
1225 }