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.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}
309 *
310 * @implSpec This implementation scans the children in left to right order.
311 *
312 * @param node {@inheritDoc}
313 * @param p {@inheritDoc}
314 * @return the result of scanning
315 */
316 @Override
317 public R visitWithField(WithFieldTree node, P p) {
318 R r = scan(node.getField(), p);
319 r = scanAndReduce(node.getValue(), p, r);
320 return r;
321 }
322
323 /**
324 * {@inheritDoc} This implementation scans the children in left to right order.
325 *
326 * @param node {@inheritDoc}
327 * @param p {@inheritDoc}
328 * @return the result of scanning
329 */
330 @Override
331 public R visitForLoop(ForLoopTree node, P p) {
332 R r = scan(node.getInitializer(), p);
333 r = scanAndReduce(node.getCondition(), p, r);
334 r = scanAndReduce(node.getUpdate(), p, r);
335 r = scanAndReduce(node.getStatement(), p, r);
336 return r;
337 }
338
339 /**
340 * {@inheritDoc}
341 *
342 * @implSpec This implementation scans the children in left to right order.
343 *
344 * @param node {@inheritDoc}
345 * @param p {@inheritDoc}
346 * @return the result of scanning
347 */
348 @Override
349 public R visitEnhancedForLoop(EnhancedForLoopTree node, P p) {
350 R r = scan(node.getVariable(), p);
351 r = scanAndReduce(node.getExpression(), p, r);
352 r = scanAndReduce(node.getStatement(), p, r);
353 return r;
354 }
355
356 /**
357 * {@inheritDoc}
358 *
359 * @implSpec This implementation scans the children in left to right order.
360 *
361 * @param node {@inheritDoc}
362 * @param p {@inheritDoc}
363 * @return the result of scanning
364 */
365 @Override
366 public R visitLabeledStatement(LabeledStatementTree node, P p) {
367 return scan(node.getStatement(), p);
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 visitSwitch(SwitchTree 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 visitSwitchExpression(SwitchExpressionTree node, P p) {
397 R r = scan(node.getExpression(), p);
398 r = scanAndReduce(node.getCases(), p, r);
399 return r;
400 }
401
402 /**
403 * {@inheritDoc}
404 *
405 * @implSpec This implementation scans the children in left to right order.
406 *
407 * @param node {@inheritDoc}
408 * @param p {@inheritDoc}
409 * @return the result of scanning
410 */
411 @Override
412 public R visitCase(CaseTree node, P p) {
413 R r = scan(node.getExpressions(), p);
414 if (node.getCaseKind() == CaseTree.CaseKind.RULE)
415 r = scanAndReduce(node.getBody(), p, r);
416 else
417 r = scanAndReduce(node.getStatements(), p, r);
418 return r;
419 }
420
421 /**
422 * {@inheritDoc}
423 *
424 * @implSpec This implementation scans the children in left to right order.
425 *
426 * @param node {@inheritDoc}
427 * @param p {@inheritDoc}
428 * @return the result of scanning
429 */
430 @Override
431 public R visitDefaultValue(DefaultValueTree node, P p) {
432 return scan(node.getType(), p);
433 }
434
435 /**
436 * {@inheritDoc} This implementation scans the children in left to right order.
437 *
438 * @param node {@inheritDoc}
439 * @param p {@inheritDoc}
440 * @return the result of scanning
441 */
442 @Override
443 public R visitSynchronized(SynchronizedTree node, P p) {
444 R r = scan(node.getExpression(), p);
445 r = scanAndReduce(node.getBlock(), p, r);
446 return r;
447 }
448
449 /**
450 * {@inheritDoc}
451 *
452 * @implSpec This implementation scans the children in left to right order.
453 *
454 * @param node {@inheritDoc}
455 * @param p {@inheritDoc}
456 * @return the result of scanning
457 */
458 @Override
459 public R visitTry(TryTree node, P p) {
460 R r = scan(node.getResources(), p);
461 r = scanAndReduce(node.getBlock(), p, r);
462 r = scanAndReduce(node.getCatches(), p, r);
463 r = scanAndReduce(node.getFinallyBlock(), p, r);
464 return r;
465 }
466
467 /**
468 * {@inheritDoc}
469 *
470 * @implSpec This implementation scans the children in left to right order.
471 *
472 * @param node {@inheritDoc}
473 * @param p {@inheritDoc}
474 * @return the result of scanning
475 */
476 @Override
477 public R visitCatch(CatchTree node, P p) {
478 R r = scan(node.getParameter(), p);
479 r = scanAndReduce(node.getBlock(), p, r);
480 return r;
481 }
482
483 /**
484 * {@inheritDoc}
485 *
486 * @implSpec This implementation scans the children in left to right order.
487 *
488 * @param node {@inheritDoc}
489 * @param p {@inheritDoc}
490 * @return the result of scanning
491 */
492 @Override
493 public R visitConditionalExpression(ConditionalExpressionTree node, P p) {
494 R r = scan(node.getCondition(), p);
495 r = scanAndReduce(node.getTrueExpression(), p, r);
496 r = scanAndReduce(node.getFalseExpression(), p, r);
497 return r;
498 }
499
500 /**
501 * {@inheritDoc}
502 *
503 * @implSpec This implementation scans the children in left to right order.
504 *
505 * @param node {@inheritDoc}
506 * @param p {@inheritDoc}
507 * @return the result of scanning
508 */
509 @Override
510 public R visitIf(IfTree node, P p) {
511 R r = scan(node.getCondition(), p);
512 r = scanAndReduce(node.getThenStatement(), p, r);
513 r = scanAndReduce(node.getElseStatement(), p, r);
514 return r;
515 }
516
517 /**
518 * {@inheritDoc}
519 *
520 * @implSpec This implementation scans the children in left to right order.
521 *
522 * @param node {@inheritDoc}
523 * @param p {@inheritDoc}
524 * @return the result of scanning
525 */
526 @Override
527 public R visitExpressionStatement(ExpressionStatementTree node, P p) {
528 return scan(node.getExpression(), p);
529 }
530
531 /**
532 * {@inheritDoc}
533 *
534 * @implSpec This implementation returns {@code null}.
535 *
536 * @param node {@inheritDoc}
537 * @param p {@inheritDoc}
538 * @return the result of scanning
539 */
540 @Override
541 public R visitBreak(BreakTree node, P p) {
542 return null;
543 }
544
545 /**
546 * {@inheritDoc}
547 *
548 * @implSpec This implementation returns {@code null}.
549 *
550 * @param node {@inheritDoc}
551 * @param p {@inheritDoc}
552 * @return the result of scanning
553 */
554 @Override
555 public R visitContinue(ContinueTree node, P p) {
556 return null;
557 }
558
559 /**
560 * {@inheritDoc}
561 *
562 * @implSpec This implementation scans the children in left to right order.
563 *
564 * @param node {@inheritDoc}
565 * @param p {@inheritDoc}
566 * @return the result of scanning
567 */
568 @Override
569 public R visitReturn(ReturnTree node, P p) {
570 return scan(node.getExpression(), p);
571 }
572
573 /**
574 * {@inheritDoc}
575 *
576 * @implSpec This implementation scans the children in left to right order.
577 *
578 * @param node {@inheritDoc}
579 * @param p {@inheritDoc}
580 * @return the result of scanning
581 */
582 @Override
583 public R visitThrow(ThrowTree node, P p) {
584 return scan(node.getExpression(), p);
585 }
586
587 /**
588 * {@inheritDoc}
589 *
590 * @implSpec This implementation scans the children in left to right order.
591 *
592 * @param node {@inheritDoc}
593 * @param p {@inheritDoc}
594 * @return the result of scanning
595 */
596 @Override
597 public R visitAssert(AssertTree node, P p) {
598 R r = scan(node.getCondition(), p);
599 r = scanAndReduce(node.getDetail(), p, r);
600 return r;
601 }
602
603 /**
604 * {@inheritDoc}
605 *
606 * @implSpec This implementation scans the children in left to right order.
607 *
608 * @param node {@inheritDoc}
609 * @param p {@inheritDoc}
610 * @return the result of scanning
611 */
612 @Override
613 public R visitMethodInvocation(MethodInvocationTree node, P p) {
614 R r = scan(node.getTypeArguments(), p);
615 r = scanAndReduce(node.getMethodSelect(), p, r);
616 r = scanAndReduce(node.getArguments(), p, r);
617 return r;
618 }
619
620 /**
621 * {@inheritDoc}
622 *
623 * @implSpec This implementation scans the children in left to right order.
624 *
625 * @param node {@inheritDoc}
626 * @param p {@inheritDoc}
627 * @return the result of scanning
628 */
629 @Override
630 public R visitNewClass(NewClassTree node, P p) {
631 R r = scan(node.getEnclosingExpression(), p);
632 r = scanAndReduce(node.getIdentifier(), p, r);
633 r = scanAndReduce(node.getTypeArguments(), p, r);
634 r = scanAndReduce(node.getArguments(), p, r);
635 r = scanAndReduce(node.getClassBody(), p, r);
636 return r;
637 }
638
639 /**
640 * {@inheritDoc}
641 *
642 * @implSpec This implementation scans the children in left to right order.
643 *
644 * @param node {@inheritDoc}
645 * @param p {@inheritDoc}
646 * @return the result of scanning
647 */
648 @Override
649 public R visitNewArray(NewArrayTree node, P p) {
650 R r = scan(node.getType(), p);
651 r = scanAndReduce(node.getDimensions(), p, r);
652 r = scanAndReduce(node.getInitializers(), p, r);
653 r = scanAndReduce(node.getAnnotations(), p, r);
654 for (Iterable< ? extends Tree> dimAnno : node.getDimAnnotations()) {
655 r = scanAndReduce(dimAnno, p, r);
656 }
657 return r;
658 }
659
660 /**
661 * {@inheritDoc}
662 *
663 * @implSpec This implementation scans the children in left to right order.
664 *
665 * @param node {@inheritDoc}
666 * @param p {@inheritDoc}
667 * @return the result of scanning
668 */
669 @Override
670 public R visitLambdaExpression(LambdaExpressionTree node, P p) {
671 R r = scan(node.getParameters(), p);
672 r = scanAndReduce(node.getBody(), p, r);
673 return r;
674 }
675
676 /**
677 * {@inheritDoc}
678 *
679 * @implSpec This implementation scans the children in left to right order.
680 *
681 * @param node {@inheritDoc}
682 * @param p {@inheritDoc}
683 * @return the result of scanning
684 */
685 @Override
686 public R visitParenthesized(ParenthesizedTree node, P p) {
687 return scan(node.getExpression(), p);
688 }
689
690 /**
691 * {@inheritDoc}
692 *
693 * @implSpec This implementation scans the children in left to right order.
694 *
695 * @param node {@inheritDoc}
696 * @param p {@inheritDoc}
697 * @return the result of scanning
698 */
699 @Override
700 public R visitAssignment(AssignmentTree node, P p) {
701 R r = scan(node.getVariable(), p);
702 r = scanAndReduce(node.getExpression(), p, r);
703 return r;
704 }
705
706 /**
707 * {@inheritDoc}
708 *
709 * @implSpec This implementation scans the children in left to right order.
710 *
711 * @param node {@inheritDoc}
712 * @param p {@inheritDoc}
713 * @return the result of scanning
714 */
715 @Override
716 public R visitCompoundAssignment(CompoundAssignmentTree node, P p) {
717 R r = scan(node.getVariable(), p);
718 r = scanAndReduce(node.getExpression(), p, r);
719 return r;
720 }
721
722 /**
723 * {@inheritDoc}
724 *
725 * @implSpec This implementation scans the children in left to right order.
726 *
727 * @param node {@inheritDoc}
728 * @param p {@inheritDoc}
729 * @return the result of scanning
730 */
731 @Override
732 public R visitUnary(UnaryTree node, P p) {
733 return scan(node.getExpression(), p);
734 }
735
736 /**
737 * {@inheritDoc}
738 *
739 * @implSpec This implementation scans the children in left to right order.
740 *
741 * @param node {@inheritDoc}
742 * @param p {@inheritDoc}
743 * @return the result of scanning
744 */
745 @Override
746 public R visitBinary(BinaryTree node, P p) {
747 R r = scan(node.getLeftOperand(), p);
748 r = scanAndReduce(node.getRightOperand(), p, r);
749 return r;
750 }
751
752 /**
753 * {@inheritDoc}
754 *
755 * @implSpec This implementation scans the children in left to right order.
756 *
757 * @param node {@inheritDoc}
758 * @param p {@inheritDoc}
759 * @return the result of scanning
760 */
761 @Override
762 public R visitTypeCast(TypeCastTree node, P p) {
763 R r = scan(node.getType(), p);
764 r = scanAndReduce(node.getExpression(), p, r);
765 return r;
766 }
767
768 /**
769 * {@inheritDoc}
770 *
771 * @implSpec This implementation scans the children in left to right order.
772 *
773 * @param node {@inheritDoc}
774 * @param p {@inheritDoc}
775 * @return the result of scanning
776 */
777 @Override
778 public R visitInstanceOf(InstanceOfTree node, P p) {
779 R r = scan(node.getExpression(), p);
780 if (node.getPattern() != null) {
781 r = scanAndReduce(node.getPattern(), p, r);
782 } else {
783 r = scanAndReduce(node.getType(), p, r);
784 }
785 return r;
786 }
787
788 /**
789 * {@inheritDoc}
790 *
791 * @implSpec This implementation scans the children in left to right order.
792 *
793 * @param node {@inheritDoc}
794 * @param p {@inheritDoc}
795 * @return the result of scanning
796 * @since 14
797 */
798 @Override
799 public R visitBindingPattern(BindingPatternTree node, P p) {
800 return scan(node.getVariable(), p);
801 }
802
803 /**
804 * {@inheritDoc}
805 *
806 * @implSpec This implementation returns {@code null}.
807 *
808 * @param node {@inheritDoc}
809 * @param p {@inheritDoc}
810 * @return the result of scanning
811 * @since 17
812 */
813 @Override
814 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true)
815 public R visitDefaultCaseLabel(DefaultCaseLabelTree node, P p) {
816 return null;
817 }
818
819 /**
820 * {@inheritDoc}
821 *
822 * @implSpec This implementation scans the children in left to right order.
823 *
824 * @param node {@inheritDoc}
825 * @param p {@inheritDoc}
826 * @return the result of scanning
827 */
828 @Override
829 public R visitArrayAccess(ArrayAccessTree node, P p) {
830 R r = scan(node.getExpression(), p);
831 r = scanAndReduce(node.getIndex(), p, r);
832 return r;
833 }
834
835 /**
836 * {@inheritDoc}
837 *
838 * @implSpec This implementation scans the children in left to right order.
839 *
840 * @param node {@inheritDoc}
841 * @param p {@inheritDoc}
842 * @return the result of scanning
843 */
844 @Override
845 public R visitMemberSelect(MemberSelectTree node, P p) {
846 return scan(node.getExpression(), p);
847 }
848
849 /**
850 * {@inheritDoc}
851 *
852 * @implSpec This implementation scans the children in left to right order.
853 *
854 * @param node {@inheritDoc}
855 * @param p {@inheritDoc}
856 * @return the result of scanning
857 * @since 17
858 */
859 @Override
860 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true)
861 public R visitParenthesizedPattern(ParenthesizedPatternTree node, P p) {
862 return scan(node.getPattern(), p);
863 }
864
865 /**
866 * {@inheritDoc}
867 *
868 * @implSpec This implementation scans the children in left to right order.
869 *
870 * @param node {@inheritDoc}
871 * @param p {@inheritDoc}
872 * @return the result of scanning
873 * @since 17
874 */
875 @Override
876 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true)
877 public R visitGuardedPattern(GuardedPatternTree node, P p) {
878 R r = scan(node.getPattern(), p);
879 return scanAndReduce(node.getExpression(), p, r);
880 }
881
882 /**
883 * {@inheritDoc}
884 *
885 * @implSpec This implementation scans the children in left to right order.
886 *
887 * @param node {@inheritDoc}
888 * @param p {@inheritDoc}
889 * @return the result of scanning
890 */
891 @Override
892 public R visitMemberReference(MemberReferenceTree node, P p) {
893 R r = scan(node.getQualifierExpression(), p);
894 r = scanAndReduce(node.getTypeArguments(), p, r);
895 return r;
896 }
897
898 /**
899 * {@inheritDoc}
900 *
901 * @implSpec This implementation returns {@code null}.
902 *
903 * @param node {@inheritDoc}
904 * @param p {@inheritDoc}
905 * @return the result of scanning
906 */
907 @Override
908 public R visitIdentifier(IdentifierTree node, P p) {
909 return null;
910 }
911
912 /**
913 * {@inheritDoc}
914 *
915 * @implSpec This implementation returns {@code null}.
916 *
917 * @param node {@inheritDoc}
918 * @param p {@inheritDoc}
919 * @return the result of scanning
920 */
921 @Override
922 public R visitLiteral(LiteralTree node, P p) {
923 return null;
924 }
925
926 /**
927 * {@inheritDoc}
928 *
929 * @implSpec This implementation returns {@code null}.
930 *
931 * @param node {@inheritDoc}
932 * @param p {@inheritDoc}
933 * @return the result of scanning
934 */
935 @Override
936 public R visitPrimitiveType(PrimitiveTypeTree node, P p) {
937 return null;
938 }
939
940 /**
941 * {@inheritDoc}
942 *
943 * @implSpec This implementation scans the children in left to right order.
944 *
945 * @param node {@inheritDoc}
946 * @param p {@inheritDoc}
947 * @return the result of scanning
948 */
949 @Override
950 public R visitArrayType(ArrayTypeTree node, P p) {
951 return scan(node.getType(), p);
952 }
953
954 /**
955 * {@inheritDoc}
956 *
957 * @implSpec This implementation scans the children in left to right order.
958 *
959 * @param node {@inheritDoc}
960 * @param p {@inheritDoc}
961 * @return the result of scanning
962 */
963 @Override
964 public R visitParameterizedType(ParameterizedTypeTree node, P p) {
965 R r = scan(node.getType(), p);
966 r = scanAndReduce(node.getTypeArguments(), p, r);
967 return r;
968 }
969
970 /**
971 * {@inheritDoc}
972 *
973 * @implSpec This implementation scans the children in left to right order.
974 *
975 * @param node {@inheritDoc}
976 * @param p {@inheritDoc}
977 * @return the result of scanning
978 */
979 @Override
980 public R visitUnionType(UnionTypeTree node, P p) {
981 return scan(node.getTypeAlternatives(), p);
982 }
983
984 /**
985 * {@inheritDoc}
986 *
987 * @implSpec This implementation scans the children in left to right order.
988 *
989 * @param node {@inheritDoc}
990 * @param p {@inheritDoc}
991 * @return the result of scanning
992 */
993 @Override
994 public R visitIntersectionType(IntersectionTypeTree node, P p) {
995 return scan(node.getBounds(), p);
996 }
997
998 /**
999 * {@inheritDoc}
1000 *
1001 * @implSpec This implementation scans the children in left to right order.
1002 *
1003 * @param node {@inheritDoc}
1004 * @param p {@inheritDoc}
1005 * @return the result of scanning
1006 */
1007 @Override
1008 public R visitTypeParameter(TypeParameterTree node, P p) {
1009 R r = scan(node.getAnnotations(), p);
1010 r = scanAndReduce(node.getBounds(), p, r);
1011 return r;
1012 }
1013
1014 /**
1015 * {@inheritDoc}
1016 *
1017 * @implSpec This implementation scans the children in left to right order.
1018 *
1019 * @param node {@inheritDoc}
1020 * @param p {@inheritDoc}
1021 * @return the result of scanning
1022 */
1023 @Override
1024 public R visitWildcard(WildcardTree node, P p) {
1025 return scan(node.getBound(), p);
1026 }
1027
1028 /**
1029 * {@inheritDoc}
1030 *
1031 * @implSpec This implementation scans the children in left to right order.
1032 *
1033 * @param node {@inheritDoc}
1034 * @param p {@inheritDoc}
1035 * @return the result of scanning
1036 */
1037 @Override
1038 public R visitModifiers(ModifiersTree node, P p) {
1039 return scan(node.getAnnotations(), p);
1040 }
1041
1042 /**
1043 * {@inheritDoc}
1044 *
1045 * @implSpec This implementation scans the children in left to right order.
1046 *
1047 * @param node {@inheritDoc}
1048 * @param p {@inheritDoc}
1049 * @return the result of scanning
1050 */
1051 @Override
1052 public R visitAnnotation(AnnotationTree node, P p) {
1053 R r = scan(node.getAnnotationType(), p);
1054 r = scanAndReduce(node.getArguments(), p, r);
1055 return r;
1056 }
1057
1058 /**
1059 * {@inheritDoc}
1060 *
1061 * @implSpec This implementation scans the children in left to right order.
1062 *
1063 * @param node {@inheritDoc}
1064 * @param p {@inheritDoc}
1065 * @return the result of scanning
1066 */
1067 @Override
1068 public R visitAnnotatedType(AnnotatedTypeTree node, P p) {
1069 R r = scan(node.getAnnotations(), p);
1070 r = scanAndReduce(node.getUnderlyingType(), p, r);
1071 return r;
1072 }
1073
1074 /**
1075 * {@inheritDoc}
1076 *
1077 * @implSpec This implementation scans the children in left to right order.
1078 *
1079 * @param node {@inheritDoc}
1080 * @param p {@inheritDoc}
1081 * @return the result of scanning
1082 */
1083 @Override
1084 public R visitModule(ModuleTree node, P p) {
1085 R r = scan(node.getAnnotations(), p);
1086 r = scanAndReduce(node.getName(), p, r);
1087 r = scanAndReduce(node.getDirectives(), 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 visitExports(ExportsTree node, P p) {
1102 R r = scan(node.getPackageName(), p);
1103 r = scanAndReduce(node.getModuleNames(), p, r);
1104 return r;
1105 }
1106
1107 /**
1108 * {@inheritDoc}
1109 *
1110 * @implSpec This implementation scans the children in left to right order.
1111 *
1112 * @param node {@inheritDoc}
1113 * @param p {@inheritDoc}
1114 * @return the result of scanning
1115 */
1116 @Override
1117 public R visitOpens(OpensTree node, P p) {
1118 R r = scan(node.getPackageName(), p);
1119 r = scanAndReduce(node.getModuleNames(), p, r);
1120 return r;
1121 }
1122
1123 /**
1124 * {@inheritDoc}
1125 *
1126 * @implSpec This implementation scans the children in left to right order.
1127 *
1128 * @param node {@inheritDoc}
1129 * @param p {@inheritDoc}
1130 * @return the result of scanning
1131 */
1132 @Override
1133 public R visitProvides(ProvidesTree node, P p) {
1134 R r = scan(node.getServiceName(), p);
1135 r = scanAndReduce(node.getImplementationNames(), p, r);
1136 return r;
1137 }
1138
1139 /**
1140 * {@inheritDoc}
1141 *
1142 * @implSpec This implementation scans the children in left to right order.
1143 *
1144 * @param node {@inheritDoc}
1145 * @param p {@inheritDoc}
1146 * @return the result of scanning
1147 */
1148 @Override
1149 public R visitRequires(RequiresTree node, P p) {
1150 return scan(node.getModuleName(), p);
1151 }
1152
1153 /**
1154 * {@inheritDoc}
1155 *
1156 * @implSpec This implementation scans the children in left to right order.
1157 *
1158 * @param node {@inheritDoc}
1159 * @param p {@inheritDoc}
1160 * @return the result of scanning
1161 */
1162 @Override
1163 public R visitUses(UsesTree node, P p) {
1164 return scan(node.getServiceName(), p);
1165 }
1166
1167 /**
1168 * {@inheritDoc}
1169 *
1170 * @implSpec This implementation returns {@code null}.
1171 *
1172 * @param node {@inheritDoc}
1173 * @param p {@inheritDoc}
1174 * @return the result of scanning
1175 */
1176 @Override
1177 public R visitOther(Tree node, P p) {
1178 return null;
1179 }
1180
1181 /**
1182 * {@inheritDoc}
1183 *
1184 * @implSpec This implementation returns {@code null}.
1185 *
1186 * @param node {@inheritDoc}
1187 * @param p {@inheritDoc}
1188 * @return the result of scanning
1189 */
1190 @Override
1191 public R visitErroneous(ErroneousTree node, P p) {
1192 return null;
1193 }
1194
1195 /**
1196 * {@inheritDoc}
1197 *
1198 * @implSpec This implementation scans the children in left to right order.
1199 *
1200 * @param node {@inheritDoc}
1201 * @param p {@inheritDoc}
1202 * @return the result of scanning
1203 */
1204 @Override
1205 public R visitYield(YieldTree node, P p) {
1206 return scan(node.getValue(), p);
1207 }
1208 }