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 simple visitor for tree nodes.
33 *
34 * @param <R> the return type of this visitor's methods. Use {@link
35 * Void} for visitors that do not need to return results.
36 * @param <P> the type of the additional parameter to this visitor's
37 * methods. Use {@code Void} for visitors that do not need an
38 * additional parameter.
39 *
40 * @author Peter von der Ahé
41 * @since 1.6
42 */
43 public class SimpleTreeVisitor <R,P> implements TreeVisitor<R,P> {
44 /**
45 * The default value, returned by the {@link #defaultAction default action}.
46 */
47 protected final R DEFAULT_VALUE;
48
49 /**
50 * Creates a visitor, with a DEFAULT_VALUE of {@code null}.
51 */
52 protected SimpleTreeVisitor() {
53 DEFAULT_VALUE = null;
54 }
55
56 /**
57 * Creates a visitor, with a specified DEFAULT_VALUE.
58 * @param defaultValue the default value to be returned by the default action
59 */
60 protected SimpleTreeVisitor(R defaultValue) {
61 DEFAULT_VALUE = defaultValue;
62 }
63
64 /**
65 * The default action, used by all visit methods that are not overridden.
66 * @param node the node being visited
67 * @param p the parameter value passed to the visit method
68 * @return the result value to be returned from the visit method
69 */
70 protected R defaultAction(Tree node, P p) {
71 return DEFAULT_VALUE;
72 }
73
74 /**
75 * Invokes the appropriate visit method specific to the type of the node.
76 * @param node the node on which to dispatch
77 * @param p a parameter to be passed to the appropriate visit method
78 * @return the value returns from the appropriate visit method
79 */
80 public final R visit(Tree node, P p) {
81 return (node == null) ? null : node.accept(this, p);
82 }
83
84 /**
85 * Invokes the appropriate visit method on each of a sequence of nodes.
86 * @param nodes the nodes on which to dispatch
87 * @param p a parameter value to be passed to each appropriate visit method
88 * @return the value return from the last of the visit methods, or null
89 * if none were called
90 */
91 public final R visit(Iterable<? extends Tree> nodes, P p) {
92 R r = null;
93 if (nodes != null)
94 for (Tree node : nodes)
95 r = visit(node, p);
96 return r;
97 }
98
99 /**
100 * {@inheritDoc}
101 *
102 * @implSpec This implementation calls {@code defaultAction}.
103 *
104 * @param node {@inheritDoc}
105 * @param p {@inheritDoc}
106 * @return the result of {@code defaultAction}
107 */
108 @Override
109 public R visitCompilationUnit(CompilationUnitTree node, P p) {
110 return defaultAction(node, p);
111 }
112
113 /**
114 * {@inheritDoc}
115 *
116 * @implSpec This implementation calls {@code defaultAction}.
117 *
118 * @param node {@inheritDoc}
119 * @param p {@inheritDoc}
120 * @return the result of {@code defaultAction}
121 */
122 @Override
123 public R visitPackage(PackageTree node, P p) {
124 return defaultAction(node, p);
125 }
126
127 /**
128 * {@inheritDoc}
129 *
130 * @implSpec This implementation calls {@code defaultAction}.
131 *
132 * @param node {@inheritDoc}
133 * @param p {@inheritDoc}
134 * @return the result of {@code defaultAction}
135 */
136 @Override
137 public R visitImport(ImportTree node, P p) {
138 return defaultAction(node, p);
139 }
140
141 /**
142 * {@inheritDoc}
143 *
144 * @implSpec This implementation calls {@code defaultAction}.
145 *
146 * @param node {@inheritDoc}
147 * @param p {@inheritDoc}
148 * @return the result of {@code defaultAction}
149 */
150 @Override
151 public R visitClass(ClassTree node, P p) {
152 return defaultAction(node, p);
153 }
154
155 /**
156 * {@inheritDoc}
157 *
158 * @implSpec This implementation calls {@code defaultAction}.
159 *
160 * @param node {@inheritDoc}
161 * @param p {@inheritDoc}
162 * @return the result of {@code defaultAction}
163 */
164 @Override
165 public R visitMethod(MethodTree node, P p) {
166 return defaultAction(node, p);
167 }
168
169 /**
170 * {@inheritDoc}
171 *
172 * @implSpec This implementation calls {@code defaultAction}.
173 *
174 * @param node {@inheritDoc}
175 * @param p {@inheritDoc}
176 * @return the result of {@code defaultAction}
177 */
178 @Override
179 public R visitVariable(VariableTree node, P p) {
180 return defaultAction(node, p);
181 }
182
183 /**
184 * {@inheritDoc}
185 *
186 * @implSpec This implementation calls {@code defaultAction}.
187 *
188 * @param node {@inheritDoc}
189 * @param p {@inheritDoc}
190 * @return the result of {@code defaultAction}
191 */
192 @Override
193 public R visitEmptyStatement(EmptyStatementTree node, P p) {
194 return defaultAction(node, p);
195 }
196
197 /**
198 * {@inheritDoc}
199 *
200 * @implSpec This implementation calls {@code defaultAction}.
201 *
202 * @param node {@inheritDoc}
203 * @param p {@inheritDoc}
204 * @return the result of {@code defaultAction}
205 */
206 @Override
207 public R visitBlock(BlockTree node, P p) {
208 return defaultAction(node, p);
209 }
210
211 /**
212 * {@inheritDoc}
213 *
214 * @implSpec This implementation calls {@code defaultAction}.
215 *
216 * @param node {@inheritDoc}
217 * @param p {@inheritDoc}
218 * @return the result of {@code defaultAction}
219 */
220 @Override
221 public R visitDoWhileLoop(DoWhileLoopTree node, P p) {
222 return defaultAction(node, p);
223 }
224
225 /**
226 * {@inheritDoc}
227 *
228 * @implSpec This implementation calls {@code defaultAction}.
229 *
230 * @param node {@inheritDoc}
231 * @param p {@inheritDoc}
232 * @return the result of {@code defaultAction}
233 */
234 @Override
235 public R visitWhileLoop(WhileLoopTree node, P p) {
236 return defaultAction(node, p);
237 }
238
239 /**
240 * {@inheritDoc} This implementation calls {@code defaultAction}.
241 *
242 * @param node {@inheritDoc}
243 * @param p {@inheritDoc}
244 * @return the result of {@code defaultAction}
245 */
246 @Override
247 public R visitForLoop(ForLoopTree node, P p) {
248 return defaultAction(node, p);
249 }
250
251 /**
252 * {@inheritDoc}
253 *
254 * @implSpec This implementation calls {@code defaultAction}.
255 *
256 * @param node {@inheritDoc}
257 * @param p {@inheritDoc}
258 * @return the result of {@code defaultAction}
259 */
260 @Override
261 public R visitEnhancedForLoop(EnhancedForLoopTree node, P p) {
262 return defaultAction(node, p);
263 }
264
265 /**
266 * {@inheritDoc}
267 *
268 * @implSpec This implementation calls {@code defaultAction}.
269 *
270 * @param node {@inheritDoc}
271 * @param p {@inheritDoc}
272 * @return the result of {@code defaultAction}
273 */
274 @Override
275 public R visitLabeledStatement(LabeledStatementTree node, P p) {
276 return defaultAction(node, p);
277 }
278
279 /**
280 * {@inheritDoc}
281 *
282 * @implSpec This implementation calls {@code defaultAction}.
283 *
284 * @param node {@inheritDoc}
285 * @param p {@inheritDoc}
286 * @return the result of {@code defaultAction}
287 */
288 @Override
289 public R visitSwitch(SwitchTree node, P p) {
290 return defaultAction(node, p);
291 }
292
293 /**
294 * {@inheritDoc}
295 *
296 * @implSpec This implementation calls {@code defaultAction}.
297 *
298 * @param node {@inheritDoc}
299 * @param p {@inheritDoc}
300 * @return the result of {@code defaultAction}
301 */
302 @Override
303 public R visitSwitchExpression(SwitchExpressionTree node, P p) {
304 return defaultAction(node, p);
305 }
306
307 /**
308 * {@inheritDoc}
309 *
310 * @implSpec This implementation calls {@code defaultAction}.
311 *
312 * @param node {@inheritDoc}
313 * @param p {@inheritDoc}
314 * @return the result of {@code defaultAction}
315 */
316 @Override
317 public R visitCase(CaseTree node, P p) {
318 return defaultAction(node, p);
319 }
320
321 /**
322 * {@inheritDoc}
323 *
324 * @implSpec This implementation calls {@code defaultAction}.
325 *
326 * @param node {@inheritDoc}
327 * @param p {@inheritDoc}
328 * @return the result of {@code defaultAction}
329 */
330 @Override
331 public R visitSynchronized(SynchronizedTree node, P p) {
332 return defaultAction(node, p);
333 }
334
335 /**
336 * {@inheritDoc}
337 *
338 * @implSpec This implementation calls {@code defaultAction}.
339 *
340 * @param node {@inheritDoc}
341 * @param p {@inheritDoc}
342 * @return the result of {@code defaultAction}
343 */
344 @Override
345 public R visitTry(TryTree node, P p) {
346 return defaultAction(node, p);
347 }
348
349 /**
350 * {@inheritDoc}
351 *
352 * @implSpec This implementation calls {@code defaultAction}.
353 *
354 * @param node {@inheritDoc}
355 * @param p {@inheritDoc}
356 * @return the result of {@code defaultAction}
357 */
358 @Override
359 public R visitCatch(CatchTree node, P p) {
360 return defaultAction(node, p);
361 }
362
363 /**
364 * {@inheritDoc}
365 *
366 * @implSpec This implementation calls {@code defaultAction}.
367 *
368 * @param node {@inheritDoc}
369 * @param p {@inheritDoc}
370 * @return the result of {@code defaultAction}
371 */
372 @Override
373 public R visitConditionalExpression(ConditionalExpressionTree node, P p) {
374 return defaultAction(node, p);
375 }
376
377 /**
378 * {@inheritDoc}
379 *
380 * @implSpec This implementation calls {@code defaultAction}.
381 *
382 * @param node {@inheritDoc}
383 * @param p {@inheritDoc}
384 * @return the result of {@code defaultAction}
385 */
386 @Override
387 public R visitIf(IfTree node, P p) {
388 return defaultAction(node, p);
389 }
390
391 /**
392 * {@inheritDoc}
393 *
394 * @implSpec This implementation calls {@code defaultAction}.
395 *
396 * @param node {@inheritDoc}
397 * @param p {@inheritDoc}
398 * @return the result of {@code defaultAction}
399 */
400 @Override
401 public R visitExpressionStatement(ExpressionStatementTree node, P p) {
402 return defaultAction(node, p);
403 }
404
405 /**
406 * {@inheritDoc}
407 *
408 * @implSpec This implementation calls {@code defaultAction}.
409 *
410 * @param node {@inheritDoc}
411 * @param p {@inheritDoc}
412 * @return the result of {@code defaultAction}
413 */
414 @Override
415 public R visitBreak(BreakTree node, P p) {
416 return defaultAction(node, p);
417 }
418
419 /**
420 * {@inheritDoc}
421 *
422 * @implSpec This implementation calls {@code defaultAction}.
423 *
424 * @param node {@inheritDoc}
425 * @param p {@inheritDoc}
426 * @return the result of {@code defaultAction}
427 */
428 @Override
429 public R visitContinue(ContinueTree node, P p) {
430 return defaultAction(node, p);
431 }
432
433 /**
434 * {@inheritDoc}
435 *
436 * @implSpec This implementation calls {@code defaultAction}.
437 *
438 * @param node {@inheritDoc}
439 * @param p {@inheritDoc}
440 * @return the result of {@code defaultAction}
441 */
442 @Override
443 public R visitReturn(ReturnTree node, P p) {
444 return defaultAction(node, p);
445 }
446
447 /**
448 * {@inheritDoc}
449 *
450 * @implSpec This implementation calls {@code defaultAction}.
451 *
452 * @param node {@inheritDoc}
453 * @param p {@inheritDoc}
454 * @return the result of {@code defaultAction}
455 */
456 @Override
457 public R visitThrow(ThrowTree node, P p) {
458 return defaultAction(node, p);
459 }
460
461 /**
462 * {@inheritDoc}
463 *
464 * @implSpec This implementation calls {@code defaultAction}.
465 *
466 * @param node {@inheritDoc}
467 * @param p {@inheritDoc}
468 * @return the result of {@code defaultAction}
469 */
470 @Override
471 public R visitAssert(AssertTree node, P p) {
472 return defaultAction(node, p);
473 }
474
475 /**
476 * {@inheritDoc}
477 *
478 * @implSpec This implementation calls {@code defaultAction}.
479 *
480 * @param node {@inheritDoc}
481 * @param p {@inheritDoc}
482 * @return the result of {@code defaultAction}
483 */
484 @Override
485 public R visitMethodInvocation(MethodInvocationTree node, P p) {
486 return defaultAction(node, p);
487 }
488
489 /**
490 * {@inheritDoc}
491 *
492 * @implSpec This implementation calls {@code defaultAction}.
493 *
494 * @param node {@inheritDoc}
495 * @param p {@inheritDoc}
496 * @return the result of {@code defaultAction}
497 */
498 @Override
499 public R visitNewClass(NewClassTree node, P p) {
500 return defaultAction(node, p);
501 }
502
503 /**
504 * {@inheritDoc}
505 *
506 * @implSpec This implementation calls {@code defaultAction}.
507 *
508 * @param node {@inheritDoc}
509 * @param p {@inheritDoc}
510 * @return the result of {@code defaultAction}
511 */
512 @Override
513 public R visitNewArray(NewArrayTree node, P p) {
514 return defaultAction(node, p);
515 }
516
517 /**
518 * {@inheritDoc}
519 *
520 * @implSpec This implementation calls {@code defaultAction}.
521 *
522 * @param node {@inheritDoc}
523 * @param p {@inheritDoc}
524 * @return the result of {@code defaultAction}
525 */
526 @Override
527 public R visitLambdaExpression(LambdaExpressionTree node, P p) {
528 return defaultAction(node, p);
529 }
530
531 /**
532 * {@inheritDoc}
533 *
534 * @implSpec This implementation calls {@code defaultAction}.
535 *
536 * @param node {@inheritDoc}
537 * @param p {@inheritDoc}
538 * @return the result of {@code defaultAction}
539 */
540 @Override
541 public R visitParenthesized(ParenthesizedTree node, P p) {
542 return defaultAction(node, p);
543 }
544
545 /**
546 * {@inheritDoc}
547 *
548 * @implSpec This implementation calls {@code defaultAction}.
549 *
550 * @param node {@inheritDoc}
551 * @param p {@inheritDoc}
552 * @return the result of {@code defaultAction}
553 */
554 @Override
555 public R visitAssignment(AssignmentTree node, P p) {
556 return defaultAction(node, p);
557 }
558
559 /**
560 * {@inheritDoc}
561 *
562 * @implSpec This implementation calls {@code defaultAction}.
563 *
564 * @param node {@inheritDoc}
565 * @param p {@inheritDoc}
566 * @return the result of {@code defaultAction}
567 */
568 @Override
569 public R visitCompoundAssignment(CompoundAssignmentTree node, P p) {
570 return defaultAction(node, p);
571 }
572
573 /**
574 * {@inheritDoc}
575 *
576 * @implSpec This implementation calls {@code defaultAction}.
577 *
578 * @param node {@inheritDoc}
579 * @param p {@inheritDoc}
580 * @return the result of {@code defaultAction}
581 */
582 @Override
583 public R visitUnary(UnaryTree node, P p) {
584 return defaultAction(node, p);
585 }
586
587 /**
588 * {@inheritDoc}
589 *
590 * @implSpec This implementation calls {@code defaultAction}.
591 *
592 * @param node {@inheritDoc}
593 * @param p {@inheritDoc}
594 * @return the result of {@code defaultAction}
595 */
596 @Override
597 public R visitBinary(BinaryTree node, P p) {
598 return defaultAction(node, p);
599 }
600
601 /**
602 * {@inheritDoc}
603 *
604 * @implSpec This implementation calls {@code defaultAction}.
605 *
606 * @param node {@inheritDoc}
607 * @param p {@inheritDoc}
608 * @return the result of {@code defaultAction}
609 */
610 @Override
611 public R visitTypeCast(TypeCastTree node, P p) {
612 return defaultAction(node, p);
613 }
614
615 /**
616 * {@inheritDoc}
617 *
618 * @implSpec This implementation calls {@code defaultAction}.
619 *
620 * @param node {@inheritDoc}
621 * @param p {@inheritDoc}
622 * @return the result of {@code defaultAction}
623 */
624 @Override
625 public R visitInstanceOf(InstanceOfTree node, P p) {
626 return defaultAction(node, p);
627 }
628
629 /**
630 * {@inheritDoc} This implementation calls {@code defaultAction}.
631 *
632 * @param node {@inheritDoc}
633 * @param p {@inheritDoc}
634 * @return the result of {@code defaultAction}
635 * @since 21
636 */
637 @Override
638 @PreviewFeature(feature=PreviewFeature.Feature.STRING_TEMPLATES, reflective=true)
639 public R visitStringTemplate(StringTemplateTree node, P p) {
640 return defaultAction(node, p);
641 }
642
643 /**
644 * {@inheritDoc}
645 *
646 * @implSpec This implementation calls {@code defaultAction}.
647 *
648 * @param node {@inheritDoc}
649 * @param p {@inheritDoc}
650 * @return the result of {@code defaultAction}
651 * @since 22
652 */
653 @Override
654 public R visitAnyPattern(AnyPatternTree node, P p) {
655 return defaultAction(node, p);
656 }
657
658 /**
659 * {@inheritDoc}
660 *
661 * @implSpec This implementation calls {@code defaultAction}.
662 *
663 * @param node {@inheritDoc}
664 * @param p {@inheritDoc}
665 * @return the result of {@code defaultAction}
666 * @since 14
667 */
668 @Override
669 public R visitBindingPattern(BindingPatternTree node, P p) {
670 return defaultAction(node, p);
671 }
672
673 /**
674 * {@inheritDoc}
675 *
676 * @implSpec This implementation calls {@code defaultAction}.
677 *
678 * @param node {@inheritDoc}
679 * @param p {@inheritDoc}
680 * @return the result of {@code defaultAction}
681 * @since 21
682 */
683 @Override
684 public R visitDefaultCaseLabel(DefaultCaseLabelTree node, P p) {
685 return defaultAction(node, p);
686 }
687
688 /**
689 * {@inheritDoc}
690 *
691 * @implSpec This implementation calls {@code defaultAction}.
692 *
693 * @param node {@inheritDoc}
694 * @param p {@inheritDoc}
695 * @return the result of {@code defaultAction}
696 * @since 21
697 */
698 @Override
699 public R visitConstantCaseLabel(ConstantCaseLabelTree node, P p) {
700 return defaultAction(node, p);
701 }
702
703 /**
704 * {@inheritDoc}
705 *
706 * @implSpec This implementation calls {@code defaultAction}.
707 *
708 * @param node {@inheritDoc}
709 * @param p {@inheritDoc}
710 * @return the result of {@code defaultAction}
711 * @since 21
712 */
713 @Override
714 public R visitDeconstructionPattern(DeconstructionPatternTree node, P p) {
715 return defaultAction(node, p);
716 }
717
718 /**
719 * {@inheritDoc}
720 *
721 * @implSpec This implementation calls {@code defaultAction}.
722 *
723 * @param node {@inheritDoc}
724 * @param p {@inheritDoc}
725 * @return the result of {@code defaultAction}
726 * @since 21
727 */
728 @Override
729 public R visitPatternCaseLabel(PatternCaseLabelTree node, P p) {
730 return defaultAction(node, p);
731 }
732
733 /**
734 * {@inheritDoc}
735 *
736 * @implSpec This implementation calls {@code defaultAction}.
737 *
738 * @param node {@inheritDoc}
739 * @param p {@inheritDoc}
740 * @return the result of {@code defaultAction}
741 */
742 @Override
743 public R visitArrayAccess(ArrayAccessTree node, P p) {
744 return defaultAction(node, p);
745 }
746
747 /**
748 * {@inheritDoc}
749 *
750 * @implSpec This implementation calls {@code defaultAction}.
751 *
752 * @param node {@inheritDoc}
753 * @param p {@inheritDoc}
754 * @return the result of {@code defaultAction}
755 */
756 @Override
757 public R visitMemberSelect(MemberSelectTree node, P p) {
758 return defaultAction(node, p);
759 }
760
761 /**
762 * {@inheritDoc}
763 *
764 * @implSpec This implementation calls {@code defaultAction}.
765 *
766 * @param node {@inheritDoc}
767 * @param p {@inheritDoc}
768 * @return the result of {@code defaultAction}
769 */
770 @Override
771 public R visitMemberReference(MemberReferenceTree node, P p) {
772 return defaultAction(node, p);
773 }
774
775 /**
776 * {@inheritDoc}
777 *
778 * @implSpec This implementation calls {@code defaultAction}.
779 *
780 * @param node {@inheritDoc}
781 * @param p {@inheritDoc}
782 * @return the result of {@code defaultAction}
783 */
784 @Override
785 public R visitIdentifier(IdentifierTree node, P p) {
786 return defaultAction(node, p);
787 }
788
789 /**
790 * {@inheritDoc}
791 *
792 * @implSpec This implementation calls {@code defaultAction}.
793 *
794 * @param node {@inheritDoc}
795 * @param p {@inheritDoc}
796 * @return the result of {@code defaultAction}
797 */
798 @Override
799 public R visitLiteral(LiteralTree node, P p) {
800 return defaultAction(node, p);
801 }
802
803 /**
804 * {@inheritDoc}
805 *
806 * @implSpec This implementation calls {@code defaultAction}.
807 *
808 * @param node {@inheritDoc}
809 * @param p {@inheritDoc}
810 * @return the result of {@code defaultAction}
811 */
812 @Override
813 public R visitPrimitiveType(PrimitiveTypeTree node, P p) {
814 return defaultAction(node, p);
815 }
816
817 /**
818 * {@inheritDoc}
819 *
820 * @implSpec This implementation calls {@code defaultAction}.
821 *
822 * @param node {@inheritDoc}
823 * @param p {@inheritDoc}
824 * @return the result of {@code defaultAction}
825 */
826 @Override
827 public R visitArrayType(ArrayTypeTree node, P p) {
828 return defaultAction(node, p);
829 }
830
831 /**
832 * {@inheritDoc}
833 *
834 * @implSpec This implementation calls {@code defaultAction}.
835 *
836 * @param node {@inheritDoc}
837 * @param p {@inheritDoc}
838 * @return the result of {@code defaultAction}
839 */
840 @Override
841 public R visitParameterizedType(ParameterizedTypeTree node, P p) {
842 return defaultAction(node, p);
843 }
844
845 /**
846 * {@inheritDoc}
847 *
848 * @implSpec This implementation calls {@code defaultAction}.
849 *
850 * @param node {@inheritDoc}
851 * @param p {@inheritDoc}
852 * @return the result of {@code defaultAction}
853 */
854 @Override
855 public R visitUnionType(UnionTypeTree node, P p) {
856 return defaultAction(node, p);
857 }
858
859 /**
860 * {@inheritDoc}
861 *
862 * @implSpec This implementation calls {@code defaultAction}.
863 *
864 * @param node {@inheritDoc}
865 * @param p {@inheritDoc}
866 * @return the result of {@code defaultAction}
867 */
868 @Override
869 public R visitIntersectionType(IntersectionTypeTree node, P p) {
870 return defaultAction(node, p);
871 }
872
873 /**
874 * {@inheritDoc}
875 *
876 * @implSpec This implementation calls {@code defaultAction}.
877 *
878 * @param node {@inheritDoc}
879 * @param p {@inheritDoc}
880 * @return the result of {@code defaultAction}
881 */
882 @Override
883 public R visitTypeParameter(TypeParameterTree node, P p) {
884 return defaultAction(node, p);
885 }
886
887 /**
888 * {@inheritDoc}
889 *
890 * @implSpec This implementation calls {@code defaultAction}.
891 *
892 * @param node {@inheritDoc}
893 * @param p {@inheritDoc}
894 * @return the result of {@code defaultAction}
895 */
896 @Override
897 public R visitWildcard(WildcardTree node, P p) {
898 return defaultAction(node, p);
899 }
900
901 /**
902 * {@inheritDoc}
903 *
904 * @implSpec This implementation calls {@code defaultAction}.
905 *
906 * @param node {@inheritDoc}
907 * @param p {@inheritDoc}
908 * @return the result of {@code defaultAction}
909 */
910 @Override
911 public R visitModifiers(ModifiersTree node, P p) {
912 return defaultAction(node, p);
913 }
914
915 /**
916 * {@inheritDoc}
917 *
918 * @implSpec This implementation calls {@code defaultAction}.
919 *
920 * @param node {@inheritDoc}
921 * @param p {@inheritDoc}
922 * @return the result of {@code defaultAction}
923 */
924 @Override
925 public R visitAnnotation(AnnotationTree node, P p) {
926 return defaultAction(node, p);
927 }
928
929 /**
930 * {@inheritDoc}
931 *
932 * @implSpec This implementation calls {@code defaultAction}.
933 *
934 * @param node {@inheritDoc}
935 * @param p {@inheritDoc}
936 * @return the result of {@code defaultAction}
937 */
938 @Override
939 public R visitAnnotatedType(AnnotatedTypeTree node, P p) {
940 return defaultAction(node, p);
941 }
942
943 /**
944 * {@inheritDoc}
945 *
946 * @implSpec This implementation calls {@code defaultAction}.
947 *
948 * @param node {@inheritDoc}
949 * @param p {@inheritDoc}
950 * @return the result of {@code defaultAction}
951 */
952 @Override
953 public R visitModule(ModuleTree node, P p) {
954 return defaultAction(node, p);
955 }
956
957 /**
958 * {@inheritDoc}
959 *
960 * @implSpec This implementation calls {@code defaultAction}.
961 *
962 * @param node {@inheritDoc}
963 * @param p {@inheritDoc}
964 * @return the result of {@code defaultAction}
965 */
966 @Override
967 public R visitExports(ExportsTree node, P p) {
968 return defaultAction(node, p);
969 }
970
971 /**
972 * {@inheritDoc}
973 *
974 * @implSpec This implementation calls {@code defaultAction}.
975 *
976 * @param node {@inheritDoc}
977 * @param p {@inheritDoc}
978 * @return the result of {@code defaultAction}
979 */
980 @Override
981 public R visitOpens(OpensTree node, P p) {
982 return defaultAction(node, p);
983 }
984
985 /**
986 * {@inheritDoc}
987 *
988 * @implSpec This implementation calls {@code defaultAction}.
989 *
990 * @param node {@inheritDoc}
991 * @param p {@inheritDoc}
992 * @return the result of {@code defaultAction}
993 */
994 @Override
995 public R visitProvides(ProvidesTree node, P p) {
996 return defaultAction(node, p);
997 }
998
999 /**
1000 * {@inheritDoc}
1001 *
1002 * @implSpec This implementation calls {@code defaultAction}.
1003 *
1004 * @param node {@inheritDoc}
1005 * @param p {@inheritDoc}
1006 * @return the result of {@code defaultAction}
1007 */
1008 @Override
1009 public R visitRequires(RequiresTree node, P p) {
1010 return defaultAction(node, p);
1011 }
1012
1013 /**
1014 * {@inheritDoc}
1015 *
1016 * @implSpec This implementation calls {@code defaultAction}.
1017 *
1018 * @param node {@inheritDoc}
1019 * @param p {@inheritDoc}
1020 * @return the result of {@code defaultAction}
1021 */
1022 @Override
1023 public R visitUses(UsesTree node, P p) {
1024 return defaultAction(node, p);
1025 }
1026
1027 /**
1028 * {@inheritDoc}
1029 *
1030 * @implSpec This implementation calls {@code defaultAction}.
1031 *
1032 * @param node {@inheritDoc}
1033 * @param p {@inheritDoc}
1034 * @return the result of {@code defaultAction}
1035 */
1036 @Override
1037 public R visitErroneous(ErroneousTree node, P p) {
1038 return defaultAction(node, p);
1039 }
1040
1041 /**
1042 * {@inheritDoc}
1043 *
1044 * @implSpec This implementation calls {@code defaultAction}.
1045 *
1046 * @param node {@inheritDoc}
1047 * @param p {@inheritDoc}
1048 * @return the result of {@code defaultAction}
1049 */
1050 @Override
1051 public R visitOther(Tree node, P p) {
1052 return defaultAction(node, p);
1053 }
1054
1055 /**
1056 * {@inheritDoc}
1057 *
1058 * @implSpec This implementation calls {@code defaultAction}.
1059 *
1060 * @param node {@inheritDoc}
1061 * @param p {@inheritDoc}
1062 * @return the result of {@code defaultAction}
1063 */
1064 @Override
1065 public R visitYield(YieldTree node, P p) {
1066 return defaultAction(node, p);
1067 }
1068 }