1 /*
2 * Copyright (c) 2005, 2019, 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
30 /**
31 * A TreeVisitor that visits all the child tree nodes.
32 * To visit nodes of a particular type, just override the
33 * corresponding visitXYZ method.
34 * Inside your method, call super.visitXYZ to visit descendant
35 * nodes.
36 *
37 * <p>The default implementation of the visitXYZ methods will determine
38 * a result as follows:
39 * <ul>
40 * <li>If the node being visited has no children, the result will be {@code null}.
41 * <li>If the node being visited has one child, the result will be the
42 * result of calling {@code scan} on that child. The child may be a simple node
43 * or itself a list of nodes.
44 * <li> If the node being visited has more than one child, the result will
45 * be determined by calling {@code scan} each child in turn, and then combining the
46 * result of each scan after the first with the cumulative result
47 * so far, as determined by the {@link #reduce} method. Each child may be either
48 * a simple node of a list of nodes. The default behavior of the {@code reduce}
49 * method is such that the result of the visitXYZ method will be the result of
50 * the last child scanned.
51 * </ul>
52 *
53 * <p>Here is an example to count the number of identifier nodes in a tree:
54 * <pre>
55 * class CountIdentifiers extends TreeScanner<Integer,Void> {
56 * {@literal @}Override
57 * public Integer visitIdentifier(IdentifierTree node, Void p) {
58 * return 1;
59 * }
60 * {@literal @}Override
61 * public Integer reduce(Integer r1, Integer r2) {
62 * return (r1 == null ? 0 : r1) + (r2 == null ? 0 : r2);
63 * }
64 * }
65 * </pre>
66 *
67 * @param <R> the return type of this visitor's methods. Use {@link
68 * Void} for visitors that do not need to return results.
69 * @param <P> the type of the additional parameter to this visitor's
70 * methods. Use {@code Void} for visitors that do not need an
71 * additional parameter.
72 *
73 * @author Peter von der Ahé
74 * @author Jonathan Gibbons
75 * @since 1.6
76 */
77 public class TreeScanner<R,P> implements TreeVisitor<R,P> {
78
79 /**
80 * Scans a single node.
81 * @param tree the node to be scanned
82 * @param p a parameter value passed to the visit method
83 * @return the result value from the visit method
84 */
85 public R scan(Tree tree, P p) {
86 return (tree == null) ? null : tree.accept(this, p);
87 }
88
89 private R scanAndReduce(Tree node, P p, R r) {
90 return reduce(scan(node, p), r);
91 }
92
93 /**
94 * Scans a sequence of nodes.
95 * @param nodes the nodes to be scanned
96 * @param p a parameter value to be passed to the visit method for each node
97 * @return the combined return value from the visit methods.
98 * The values are combined using the {@link #reduce reduce} method.
99 */
100 public R scan(Iterable<? extends Tree> nodes, P p) {
101 R r = null;
102 if (nodes != null) {
103 boolean first = true;
104 for (Tree node : nodes) {
105 r = (first ? scan(node, p) : scanAndReduce(node, p, r));
106 first = false;
107 }
108 }
109 return r;
110 }
111
112 private R scanAndReduce(Iterable<? extends Tree> nodes, P p, R r) {
113 return reduce(scan(nodes, p), r);
114 }
115
116 /**
117 * Reduces two results into a combined result.
118 * The default implementation is to return the first parameter.
119 * The general contract of the method is that it may take any action whatsoever.
120 * @param r1 the first of the values to be combined
121 * @param r2 the second of the values to be combined
122 * @return the result of combining the two parameters
123 */
124 public R reduce(R r1, R r2) {
125 return r1;
126 }
127
128
129 /* ***************************************************************************
130 * Visitor methods
131 ****************************************************************************/
132
133 /**
134 * {@inheritDoc} This implementation scans the children in left to right order.
135 *
136 * @param node {@inheritDoc}
137 * @param p {@inheritDoc}
138 * @return the result of scanning
139 */
140 @Override
141 public R visitCompilationUnit(CompilationUnitTree node, P p) {
142 R r = scan(node.getPackage(), p);
143 r = scanAndReduce(node.getImports(), p, r);
144 r = scanAndReduce(node.getTypeDecls(), p, r);
145 return r;
146 }
147
148 /**
149 * {@inheritDoc} This implementation scans the children in left to right order.
150 *
151 * @param node {@inheritDoc}
152 * @param p {@inheritDoc}
153 * @return the result of scanning
154 */
155 @Override
156 public R visitPackage(PackageTree node, P p) {
157 R r = scan(node.getAnnotations(), p);
158 r = scanAndReduce(node.getPackageName(), p, r);
159 return r;
160 }
161
162 /**
163 * {@inheritDoc} This implementation scans the children in left to right order.
164 *
165 * @param node {@inheritDoc}
166 * @param p {@inheritDoc}
167 * @return the result of scanning
168 */
169 @Override
170 public R visitImport(ImportTree node, P p) {
171 return scan(node.getQualifiedIdentifier(), p);
172 }
173
174 /**
175 * {@inheritDoc} This implementation scans the children in left to right order.
176 *
177 * @param node {@inheritDoc}
178 * @param p {@inheritDoc}
179 * @return the result of scanning
180 */
181 @Override
182 public R visitClass(ClassTree node, P p) {
183 R r = scan(node.getModifiers(), p);
184 r = scanAndReduce(node.getTypeParameters(), p, r);
185 r = scanAndReduce(node.getExtendsClause(), p, r);
186 r = scanAndReduce(node.getImplementsClause(), p, r);
187 r = scanAndReduce(node.getMembers(), p, r);
188 return r;
189 }
190
191 /**
192 * {@inheritDoc} This implementation scans the children in left to right order.
193 *
194 * @param node {@inheritDoc}
195 * @param p {@inheritDoc}
196 * @return the result of scanning
197 */
198 @Override
199 public R visitMethod(MethodTree node, P p) {
200 R r = scan(node.getModifiers(), p);
201 r = scanAndReduce(node.getReturnType(), p, r);
202 r = scanAndReduce(node.getTypeParameters(), p, r);
203 r = scanAndReduce(node.getParameters(), p, r);
204 r = scanAndReduce(node.getReceiverParameter(), p, r);
205 r = scanAndReduce(node.getThrows(), p, r);
206 r = scanAndReduce(node.getBody(), p, r);
207 r = scanAndReduce(node.getDefaultValue(), p, r);
208 return r;
209 }
210
211 /**
212 * {@inheritDoc} This implementation scans the children in left to right order.
213 *
214 * @param node {@inheritDoc}
215 * @param p {@inheritDoc}
216 * @return the result of scanning
217 */
218 @Override
219 public R visitVariable(VariableTree node, P p) {
220 R r = scan(node.getModifiers(), p);
221 r = scanAndReduce(node.getType(), p, r);
222 r = scanAndReduce(node.getNameExpression(), p, r);
223 r = scanAndReduce(node.getInitializer(), p, r);
224 return r;
225 }
226
227 /**
228 * {@inheritDoc} This implementation returns {@code null}.
229 *
230 * @param node {@inheritDoc}
231 * @param p {@inheritDoc}
232 * @return the result of scanning
233 */
234 @Override
235 public R visitEmptyStatement(EmptyStatementTree node, P p) {
236 return null;
237 }
238
239 /**
240 * {@inheritDoc} This implementation scans the children in left to right order.
241 *
242 * @param node {@inheritDoc}
243 * @param p {@inheritDoc}
244 * @return the result of scanning
245 */
246 @Override
247 public R visitBlock(BlockTree node, P p) {
248 return scan(node.getStatements(), p);
249 }
250
251 /**
252 * {@inheritDoc} This implementation scans the children in left to right order.
253 *
254 * @param node {@inheritDoc}
255 * @param p {@inheritDoc}
256 * @return the result of scanning
257 */
258 @Override
259 public R visitDoWhileLoop(DoWhileLoopTree node, P p) {
260 R r = scan(node.getStatement(), p);
261 r = scanAndReduce(node.getCondition(), p, r);
262 return r;
263 }
264
265 /**
266 * {@inheritDoc} This implementation scans the children in left to right order.
267 *
268 * @param node {@inheritDoc}
269 * @param p {@inheritDoc}
270 * @return the result of scanning
271 */
272 @Override
273 public R visitWhileLoop(WhileLoopTree node, P p) {
274 R r = scan(node.getCondition(), p);
275 r = scanAndReduce(node.getStatement(), p, r);
276 return r;
277 }
278
279 /**
280 * {@inheritDoc} This implementation scans the children in left to right order.
281 *
282 * @param node {@inheritDoc}
283 * @param p {@inheritDoc}
284 * @return the result of scanning
285 */
286 @Override
287 public R visitForLoop(ForLoopTree node, P p) {
288 R r = scan(node.getInitializer(), p);
289 r = scanAndReduce(node.getCondition(), p, r);
290 r = scanAndReduce(node.getUpdate(), p, r);
291 r = scanAndReduce(node.getStatement(), p, r);
292 return r;
293 }
294
295 /**
296 * {@inheritDoc} This implementation scans the children in left to right order.
297 *
298 * @param node {@inheritDoc}
299 * @param p {@inheritDoc}
300 * @return the result of scanning
301 */
302 @Override
303 public R visitEnhancedForLoop(EnhancedForLoopTree node, P p) {
304 R r = scan(node.getVariable(), p);
305 r = scanAndReduce(node.getExpression(), p, r);
306 r = scanAndReduce(node.getStatement(), p, r);
307 return r;
308 }
309
310 /**
311 * {@inheritDoc} This implementation scans the children in left to right order.
312 *
313 * @param node {@inheritDoc}
314 * @param p {@inheritDoc}
315 * @return the result of scanning
316 */
317 @Override
318 public R visitLabeledStatement(LabeledStatementTree node, P p) {
319 return scan(node.getStatement(), p);
320 }
321
322 /**
323 * {@inheritDoc} This implementation scans the children in left to right order.
324 *
325 * @param node {@inheritDoc}
326 * @param p {@inheritDoc}
327 * @return the result of scanning
328 */
329 @Override
330 public R visitSwitch(SwitchTree node, P p) {
331 R r = scan(node.getExpression(), p);
332 r = scanAndReduce(node.getCases(), p, r);
333 return r;
334 }
335
336 /**
337 * {@preview Associated with switch expressions, a preview feature of
338 * the Java language.
339 *
340 * This method is associated with <i>switch expressions</i>, a preview
341 * feature of the Java language. Preview features
342 * may be removed in a future release, or upgraded to permanent
343 * features of the Java language.}
344 *
345 * {@inheritDoc} This implementation scans the children in left to right order.
346 *
347 * @param node {@inheritDoc}
348 * @param p {@inheritDoc}
349 * @return the result of scanning
350 */
351 @Override
352 @jdk.internal.PreviewFeature(feature=jdk.internal.PreviewFeature.Feature.SWITCH_EXPRESSIONS)
353 @SuppressWarnings("preview")
354 public R visitSwitchExpression(SwitchExpressionTree node, P p) {
355 R r = scan(node.getExpression(), p);
356 r = scanAndReduce(node.getCases(), p, r);
357 return r;
358 }
359
360 /**
361 * {@inheritDoc} This implementation scans the children in left to right order.
362 *
363 * @param node {@inheritDoc}
364 * @param p {@inheritDoc}
365 * @return the result of scanning
366 */
367 @Override
368 @SuppressWarnings("preview")
369 public R visitCase(CaseTree node, P p) {
370 R r = scan(node.getExpressions(), p);
371 if (node.getCaseKind() == CaseTree.CaseKind.RULE)
372 r = scanAndReduce(node.getBody(), p, r);
373 else
374 r = scanAndReduce(node.getStatements(), p, r);
375 return r;
376 }
377
378 /**
379 * {@inheritDoc} This implementation scans the children in left to right order.
380 *
381 * @param node {@inheritDoc}
382 * @param p {@inheritDoc}
383 * @return the result of scanning
384 */
385 @Override
386 public R visitSynchronized(SynchronizedTree node, P p) {
387 R r = scan(node.getExpression(), p);
388 r = scanAndReduce(node.getBlock(), p, r);
389 return r;
390 }
391
392 /**
393 * {@inheritDoc} This implementation scans the children in left to right order.
394 *
395 * @param node {@inheritDoc}
396 * @param p {@inheritDoc}
397 * @return the result of scanning
398 */
399 @Override
400 public R visitTry(TryTree node, P p) {
401 R r = scan(node.getResources(), p);
402 r = scanAndReduce(node.getBlock(), p, r);
403 r = scanAndReduce(node.getCatches(), p, r);
404 r = scanAndReduce(node.getFinallyBlock(), p, r);
405 return r;
406 }
407
408 /**
409 * {@inheritDoc} 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 visitCatch(CatchTree node, P p) {
417 R r = scan(node.getParameter(), p);
418 r = scanAndReduce(node.getBlock(), p, r);
419 return r;
420 }
421
422 /**
423 * {@inheritDoc} This implementation scans the children in left to right order.
424 *
425 * @param node {@inheritDoc}
426 * @param p {@inheritDoc}
427 * @return the result of scanning
428 */
429 @Override
430 public R visitConditionalExpression(ConditionalExpressionTree node, P p) {
431 R r = scan(node.getCondition(), p);
432 r = scanAndReduce(node.getTrueExpression(), p, r);
433 r = scanAndReduce(node.getFalseExpression(), p, r);
434 return r;
435 }
436
437 /**
438 * {@inheritDoc} This implementation scans the children in left to right order.
439 *
440 * @param node {@inheritDoc}
441 * @param p {@inheritDoc}
442 * @return the result of scanning
443 */
444 @Override
445 public R visitIf(IfTree node, P p) {
446 R r = scan(node.getCondition(), p);
447 r = scanAndReduce(node.getThenStatement(), p, r);
448 r = scanAndReduce(node.getElseStatement(), p, r);
449 return r;
450 }
451
452 /**
453 * {@inheritDoc} This implementation scans the children in left to right order.
454 *
455 * @param node {@inheritDoc}
456 * @param p {@inheritDoc}
457 * @return the result of scanning
458 */
459 @Override
460 public R visitExpressionStatement(ExpressionStatementTree node, P p) {
461 return scan(node.getExpression(), p);
462 }
463
464 /**
465 * {@inheritDoc} This implementation returns {@code null}.
466 *
467 * @param node {@inheritDoc}
468 * @param p {@inheritDoc}
469 * @return the result of scanning
470 */
471 @Override
472 public R visitBreak(BreakTree node, P p) {
473 return null;
474 }
475
476 /**
477 * {@inheritDoc} This implementation returns {@code null}.
478 *
479 * @param node {@inheritDoc}
480 * @param p {@inheritDoc}
481 * @return the result of scanning
482 */
483 @Override
484 public R visitContinue(ContinueTree node, P p) {
485 return null;
486 }
487
488 /**
489 * {@inheritDoc} This implementation scans the children in left to right order.
490 *
491 * @param node {@inheritDoc}
492 * @param p {@inheritDoc}
493 * @return the result of scanning
494 */
495 @Override
496 public R visitReturn(ReturnTree node, P p) {
497 return scan(node.getExpression(), p);
498 }
499
500 /**
501 * {@inheritDoc} This implementation scans the children in left to right order.
502 *
503 * @param node {@inheritDoc}
504 * @param p {@inheritDoc}
505 * @return the result of scanning
506 */
507 @Override
508 public R visitThrow(ThrowTree node, P p) {
509 return scan(node.getExpression(), p);
510 }
511
512 /**
513 * {@inheritDoc} This implementation scans the children in left to right order.
514 *
515 * @param node {@inheritDoc}
516 * @param p {@inheritDoc}
517 * @return the result of scanning
518 */
519 @Override
520 public R visitAssert(AssertTree node, P p) {
521 R r = scan(node.getCondition(), p);
522 r = scanAndReduce(node.getDetail(), p, r);
523 return r;
524 }
525
526 /**
527 * {@inheritDoc} This implementation scans the children in left to right order.
528 *
529 * @param node {@inheritDoc}
530 * @param p {@inheritDoc}
531 * @return the result of scanning
532 */
533 @Override
534 public R visitMethodInvocation(MethodInvocationTree node, P p) {
535 R r = scan(node.getTypeArguments(), p);
536 r = scanAndReduce(node.getMethodSelect(), p, r);
537 r = scanAndReduce(node.getArguments(), p, r);
538 return r;
539 }
540
541 /**
542 * {@inheritDoc} This implementation scans the children in left to right order.
543 *
544 * @param node {@inheritDoc}
545 * @param p {@inheritDoc}
546 * @return the result of scanning
547 */
548 @Override
549 public R visitNewClass(NewClassTree node, P p) {
550 R r = scan(node.getEnclosingExpression(), p);
551 r = scanAndReduce(node.getIdentifier(), p, r);
552 r = scanAndReduce(node.getTypeArguments(), p, r);
553 r = scanAndReduce(node.getArguments(), p, r);
554 r = scanAndReduce(node.getClassBody(), p, r);
555 return r;
556 }
557
558 /**
559 * {@inheritDoc} This implementation scans the children in left to right order.
560 *
561 * @param node {@inheritDoc}
562 * @param p {@inheritDoc}
563 * @return the result of scanning
564 */
565 @Override
566 public R visitNewArray(NewArrayTree node, P p) {
567 R r = scan(node.getType(), p);
568 r = scanAndReduce(node.getDimensions(), p, r);
569 r = scanAndReduce(node.getInitializers(), p, r);
570 r = scanAndReduce(node.getAnnotations(), p, r);
571 for (Iterable< ? extends Tree> dimAnno : node.getDimAnnotations()) {
572 r = scanAndReduce(dimAnno, p, r);
573 }
574 return r;
575 }
576
577 /**
578 * {@inheritDoc} This implementation scans the children in left to right order.
579 *
580 * @param node {@inheritDoc}
581 * @param p {@inheritDoc}
582 * @return the result of scanning
583 */
584 @Override
585 public R visitLambdaExpression(LambdaExpressionTree node, P p) {
586 R r = scan(node.getParameters(), p);
587 r = scanAndReduce(node.getBody(), p, r);
588 return r;
589 }
590
591 /**
592 * {@inheritDoc} This implementation scans the children in left to right order.
593 *
594 * @param node {@inheritDoc}
595 * @param p {@inheritDoc}
596 * @return the result of scanning
597 */
598 @Override
599 public R visitParenthesized(ParenthesizedTree node, P p) {
600 return scan(node.getExpression(), p);
601 }
602
603 /**
604 * {@inheritDoc} This implementation scans the children in left to right order.
605 *
606 * @param node {@inheritDoc}
607 * @param p {@inheritDoc}
608 * @return the result of scanning
609 */
610 @Override
611 public R visitAssignment(AssignmentTree node, P p) {
612 R r = scan(node.getVariable(), p);
613 r = scanAndReduce(node.getExpression(), p, r);
614 return r;
615 }
616
617 /**
618 * {@inheritDoc} This implementation scans the children in left to right order.
619 *
620 * @param node {@inheritDoc}
621 * @param p {@inheritDoc}
622 * @return the result of scanning
623 */
624 @Override
625 public R visitCompoundAssignment(CompoundAssignmentTree node, P p) {
626 R r = scan(node.getVariable(), p);
627 r = scanAndReduce(node.getExpression(), p, r);
628 return r;
629 }
630
631 /**
632 * {@inheritDoc} This implementation scans the children in left to right order.
633 *
634 * @param node {@inheritDoc}
635 * @param p {@inheritDoc}
636 * @return the result of scanning
637 */
638 @Override
639 public R visitUnary(UnaryTree node, P p) {
640 return scan(node.getExpression(), p);
641 }
642
643 /**
644 * {@inheritDoc} This implementation scans the children in left to right order.
645 *
646 * @param node {@inheritDoc}
647 * @param p {@inheritDoc}
648 * @return the result of scanning
649 */
650 @Override
651 public R visitBinary(BinaryTree node, P p) {
652 R r = scan(node.getLeftOperand(), p);
653 r = scanAndReduce(node.getRightOperand(), p, r);
654 return r;
655 }
656
657 /**
658 * {@inheritDoc} This implementation scans the children in left to right order.
659 *
660 * @param node {@inheritDoc}
661 * @param p {@inheritDoc}
662 * @return the result of scanning
663 */
664 @Override
665 public R visitTypeCast(TypeCastTree node, P p) {
666 R r = scan(node.getType(), p);
667 r = scanAndReduce(node.getExpression(), p, r);
668 return r;
669 }
670
671 /**
672 * {@inheritDoc} This implementation scans the children in left to right order.
673 *
674 * @param node {@inheritDoc}
675 * @param p {@inheritDoc}
676 * @return the result of scanning
677 */
678 @Override
679 public R visitInstanceOf(InstanceOfTree node, P p) {
680 R r = scan(node.getExpression(), p);
681 r = scanAndReduce(node.getType(), p, r);
682 return r;
683 }
684
685 /**
686 * {@inheritDoc} This implementation scans the children in left to right order.
687 *
688 * @param node {@inheritDoc}
689 * @param p {@inheritDoc}
690 * @return the result of scanning
691 */
692 @Override
693 public R visitArrayAccess(ArrayAccessTree node, P p) {
694 R r = scan(node.getExpression(), p);
695 r = scanAndReduce(node.getIndex(), p, r);
696 return r;
697 }
698
699 /**
700 * {@inheritDoc} This implementation scans the children in left to right order.
701 *
702 * @param node {@inheritDoc}
703 * @param p {@inheritDoc}
704 * @return the result of scanning
705 */
706 @Override
707 public R visitMemberSelect(MemberSelectTree node, P p) {
708 return scan(node.getExpression(), p);
709 }
710
711 /**
712 * {@inheritDoc} 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 visitMemberReference(MemberReferenceTree node, P p) {
720 R r = scan(node.getQualifierExpression(), p);
721 r = scanAndReduce(node.getTypeArguments(), p, r);
722 return r;
723 }
724
725 /**
726 * {@inheritDoc} This implementation returns {@code null}.
727 *
728 * @param node {@inheritDoc}
729 * @param p {@inheritDoc}
730 * @return the result of scanning
731 */
732 @Override
733 public R visitIdentifier(IdentifierTree node, P p) {
734 return null;
735 }
736
737 /**
738 * {@inheritDoc} This implementation returns {@code null}.
739 *
740 * @param node {@inheritDoc}
741 * @param p {@inheritDoc}
742 * @return the result of scanning
743 */
744 @Override
745 public R visitLiteral(LiteralTree node, P p) {
746 return null;
747 }
748
749 /**
750 * {@inheritDoc} This implementation returns {@code null}.
751 *
752 * @param node {@inheritDoc}
753 * @param p {@inheritDoc}
754 * @return the result of scanning
755 */
756 @Override
757 public R visitPrimitiveType(PrimitiveTypeTree node, P p) {
758 return null;
759 }
760
761 /**
762 * {@inheritDoc} This implementation scans the children in left to right order.
763 *
764 * @param node {@inheritDoc}
765 * @param p {@inheritDoc}
766 * @return the result of scanning
767 */
768 @Override
769 public R visitArrayType(ArrayTypeTree node, P p) {
770 return scan(node.getType(), p);
771 }
772
773 /**
774 * {@inheritDoc} This implementation scans the children in left to right order.
775 *
776 * @param node {@inheritDoc}
777 * @param p {@inheritDoc}
778 * @return the result of scanning
779 */
780 @Override
781 public R visitParameterizedType(ParameterizedTypeTree node, P p) {
782 R r = scan(node.getType(), p);
783 r = scanAndReduce(node.getTypeArguments(), p, r);
784 return r;
785 }
786
787 /**
788 * {@inheritDoc} This implementation scans the children in left to right order.
789 *
790 * @param node {@inheritDoc}
791 * @param p {@inheritDoc}
792 * @return the result of scanning
793 */
794 @Override
795 public R visitUnionType(UnionTypeTree node, P p) {
796 return scan(node.getTypeAlternatives(), p);
797 }
798
799 /**
800 * {@inheritDoc} This implementation scans the children in left to right order.
801 *
802 * @param node {@inheritDoc}
803 * @param p {@inheritDoc}
804 * @return the result of scanning
805 */
806 @Override
807 public R visitIntersectionType(IntersectionTypeTree node, P p) {
808 return scan(node.getBounds(), p);
809 }
810
811 /**
812 * {@inheritDoc} This implementation scans the children in left to right order.
813 *
814 * @param node {@inheritDoc}
815 * @param p {@inheritDoc}
816 * @return the result of scanning
817 */
818 @Override
819 public R visitTypeParameter(TypeParameterTree node, P p) {
820 R r = scan(node.getAnnotations(), p);
821 r = scanAndReduce(node.getBounds(), p, r);
822 return r;
823 }
824
825 /**
826 * {@inheritDoc} This implementation scans the children in left to right order.
827 *
828 * @param node {@inheritDoc}
829 * @param p {@inheritDoc}
830 * @return the result of scanning
831 */
832 @Override
833 public R visitWildcard(WildcardTree node, P p) {
834 return scan(node.getBound(), p);
835 }
836
837 /**
838 * {@inheritDoc} 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 visitModifiers(ModifiersTree node, P p) {
846 return scan(node.getAnnotations(), p);
847 }
848
849 /**
850 * {@inheritDoc} This implementation scans the children in left to right order.
851 *
852 * @param node {@inheritDoc}
853 * @param p {@inheritDoc}
854 * @return the result of scanning
855 */
856 @Override
857 public R visitAnnotation(AnnotationTree node, P p) {
858 R r = scan(node.getAnnotationType(), p);
859 r = scanAndReduce(node.getArguments(), p, r);
860 return r;
861 }
862
863 /**
864 * {@inheritDoc} This implementation scans the children in left to right order.
865 *
866 * @param node {@inheritDoc}
867 * @param p {@inheritDoc}
868 * @return the result of scanning
869 */
870 @Override
871 public R visitAnnotatedType(AnnotatedTypeTree node, P p) {
872 R r = scan(node.getAnnotations(), p);
873 r = scanAndReduce(node.getUnderlyingType(), p, r);
874 return r;
875 }
876
877 @Override
878 public R visitModule(ModuleTree node, P p) {
879 R r = scan(node.getAnnotations(), p);
880 r = scanAndReduce(node.getName(), p, r);
881 r = scanAndReduce(node.getDirectives(), p, r);
882 return r;
883 }
884
885 @Override
886 public R visitExports(ExportsTree node, P p) {
887 R r = scan(node.getPackageName(), p);
888 r = scanAndReduce(node.getModuleNames(), p, r);
889 return r;
890 }
891
892 @Override
893 public R visitOpens(OpensTree node, P p) {
894 R r = scan(node.getPackageName(), p);
895 r = scanAndReduce(node.getModuleNames(), p, r);
896 return r;
897 }
898
899 @Override
900 public R visitProvides(ProvidesTree node, P p) {
901 R r = scan(node.getServiceName(), p);
902 r = scanAndReduce(node.getImplementationNames(), p, r);
903 return r;
904 }
905
906 @Override
907 public R visitRequires(RequiresTree node, P p) {
908 return scan(node.getModuleName(), p);
909 }
910
911 @Override
912 public R visitUses(UsesTree node, P p) {
913 return scan(node.getServiceName(), p);
914 }
915
916 /**
917 * {@inheritDoc} This implementation returns {@code null}.
918 *
919 * @param node {@inheritDoc}
920 * @param p {@inheritDoc}
921 * @return the result of scanning
922 */
923 @Override
924 public R visitOther(Tree node, P p) {
925 return null;
926 }
927
928 /**
929 * {@inheritDoc} 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 visitErroneous(ErroneousTree node, P p) {
937 return null;
938 }
939
940 /**
941 * {@preview Associated with switch expressions, a preview feature of
942 * the Java language.
943 *
944 * This method is associated with <i>switch expressions</i>, a preview
945 * feature of the Java language. Preview features
946 * may be removed in a future release, or upgraded to permanent
947 * features of the Java language.}
948 *
949 * {@inheritDoc} This implementation returns {@code null}.
950 *
951 * @param node {@inheritDoc}
952 * @param p {@inheritDoc}
953 * @return the result of scanning
954 */
955 @Override
956 @jdk.internal.PreviewFeature(feature=jdk.internal.PreviewFeature.Feature.SWITCH_EXPRESSIONS)
957 @SuppressWarnings("preview")
958 public R visitYield(YieldTree node, P p) {
959 return scan(node.getValue(), p);
960 }
961 }