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 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} 241 * 242 * @implSpec This implementation calls {@code defaultAction}. 243 * 244 * @param node {@inheritDoc} 245 * @param p {@inheritDoc} 246 * @return the result of {@code defaultAction} 247 */ 248 @Override 249 public R visitForLoop(ForLoopTree node, P p) { 250 return defaultAction(node, p); 251 } 252 253 /** 254 * {@inheritDoc} 255 * 256 * @implSpec This implementation calls {@code defaultAction}. 257 * 258 * @param node {@inheritDoc} 259 * @param p {@inheritDoc} 260 * @return the result of {@code defaultAction} 261 */ 262 @Override 263 public R visitEnhancedForLoop(EnhancedForLoopTree node, P p) { 264 return defaultAction(node, p); 265 } 266 267 /** 268 * {@inheritDoc} 269 * 270 * @implSpec This implementation calls {@code defaultAction}. 271 * 272 * @param node {@inheritDoc} 273 * @param p {@inheritDoc} 274 * @return the result of {@code defaultAction} 275 */ 276 @Override 277 public R visitLabeledStatement(LabeledStatementTree node, P p) { 278 return defaultAction(node, p); 279 } 280 281 /** 282 * {@inheritDoc} 283 * 284 * @implSpec This implementation calls {@code defaultAction}. 285 * 286 * @param node {@inheritDoc} 287 * @param p {@inheritDoc} 288 * @return the result of {@code defaultAction} 289 */ 290 @Override 291 public R visitSwitch(SwitchTree node, P p) { 292 return defaultAction(node, p); 293 } 294 295 /** 296 * {@inheritDoc} 297 * 298 * @implSpec This implementation calls {@code defaultAction}. 299 * 300 * @param node {@inheritDoc} 301 * @param p {@inheritDoc} 302 * @return the result of {@code defaultAction} 303 */ 304 @Override 305 public R visitSwitchExpression(SwitchExpressionTree node, P p) { 306 return defaultAction(node, p); 307 } 308 309 /** 310 * {@inheritDoc} 311 * 312 * @implSpec This implementation calls {@code defaultAction}. 313 * 314 * @param node {@inheritDoc} 315 * @param p {@inheritDoc} 316 * @return the result of {@code defaultAction} 317 */ 318 @Override 319 public R visitCase(CaseTree node, P p) { 320 return defaultAction(node, p); 321 } 322 323 /** 324 * {@inheritDoc} 325 * 326 * @implSpec This implementation calls {@code defaultAction}. 327 * 328 * @param node {@inheritDoc} 329 * @param p {@inheritDoc} 330 * @return the result of {@code defaultAction} 331 */ 332 @Override 333 public R visitSynchronized(SynchronizedTree node, P p) { 334 return defaultAction(node, p); 335 } 336 337 /** 338 * {@inheritDoc} 339 * 340 * @implSpec This implementation calls {@code defaultAction}. 341 * 342 * @param node {@inheritDoc} 343 * @param p {@inheritDoc} 344 * @return the result of {@code defaultAction} 345 */ 346 @Override 347 public R visitTry(TryTree node, P p) { 348 return defaultAction(node, p); 349 } 350 351 /** 352 * {@inheritDoc} 353 * 354 * @implSpec This implementation calls {@code defaultAction}. 355 * 356 * @param node {@inheritDoc} 357 * @param p {@inheritDoc} 358 * @return the result of {@code defaultAction} 359 */ 360 @Override 361 public R visitCatch(CatchTree node, P p) { 362 return defaultAction(node, p); 363 } 364 365 /** 366 * {@inheritDoc} 367 * 368 * @implSpec This implementation calls {@code defaultAction}. 369 * 370 * @param node {@inheritDoc} 371 * @param p {@inheritDoc} 372 * @return the result of {@code defaultAction} 373 */ 374 @Override 375 public R visitConditionalExpression(ConditionalExpressionTree node, P p) { 376 return defaultAction(node, p); 377 } 378 379 /** 380 * {@inheritDoc} 381 * 382 * @implSpec This implementation calls {@code defaultAction}. 383 * 384 * @param node {@inheritDoc} 385 * @param p {@inheritDoc} 386 * @return the result of {@code defaultAction} 387 */ 388 @Override 389 public R visitIf(IfTree node, P p) { 390 return defaultAction(node, p); 391 } 392 393 /** 394 * {@inheritDoc} 395 * 396 * @implSpec This implementation calls {@code defaultAction}. 397 * 398 * @param node {@inheritDoc} 399 * @param p {@inheritDoc} 400 * @return the result of {@code defaultAction} 401 */ 402 @Override 403 public R visitExpressionStatement(ExpressionStatementTree node, P p) { 404 return defaultAction(node, p); 405 } 406 407 /** 408 * {@inheritDoc} 409 * 410 * @implSpec This implementation calls {@code defaultAction}. 411 * 412 * @param node {@inheritDoc} 413 * @param p {@inheritDoc} 414 * @return the result of {@code defaultAction} 415 */ 416 @Override 417 public R visitBreak(BreakTree node, P p) { 418 return defaultAction(node, p); 419 } 420 421 /** 422 * {@inheritDoc} 423 * 424 * @implSpec This implementation calls {@code defaultAction}. 425 * 426 * @param node {@inheritDoc} 427 * @param p {@inheritDoc} 428 * @return the result of {@code defaultAction} 429 */ 430 @Override 431 public R visitContinue(ContinueTree node, P p) { 432 return defaultAction(node, p); 433 } 434 435 /** 436 * {@inheritDoc} 437 * 438 * @implSpec This implementation calls {@code defaultAction}. 439 * 440 * @param node {@inheritDoc} 441 * @param p {@inheritDoc} 442 * @return the result of {@code defaultAction} 443 */ 444 @Override 445 public R visitReturn(ReturnTree node, P p) { 446 return defaultAction(node, p); 447 } 448 449 /** 450 * {@inheritDoc} 451 * 452 * @implSpec This implementation calls {@code defaultAction}. 453 * 454 * @param node {@inheritDoc} 455 * @param p {@inheritDoc} 456 * @return the result of {@code defaultAction} 457 */ 458 @Override 459 public R visitThrow(ThrowTree node, P p) { 460 return defaultAction(node, p); 461 } 462 463 /** 464 * {@inheritDoc} 465 * 466 * @implSpec This implementation calls {@code defaultAction}. 467 * 468 * @param node {@inheritDoc} 469 * @param p {@inheritDoc} 470 * @return the result of {@code defaultAction} 471 */ 472 @Override 473 public R visitAssert(AssertTree node, P p) { 474 return defaultAction(node, p); 475 } 476 477 /** 478 * {@inheritDoc} 479 * 480 * @implSpec This implementation calls {@code defaultAction}. 481 * 482 * @param node {@inheritDoc} 483 * @param p {@inheritDoc} 484 * @return the result of {@code defaultAction} 485 */ 486 @Override 487 public R visitMethodInvocation(MethodInvocationTree node, P p) { 488 return defaultAction(node, p); 489 } 490 491 /** 492 * {@inheritDoc} 493 * 494 * @implSpec This implementation calls {@code defaultAction}. 495 * 496 * @param node {@inheritDoc} 497 * @param p {@inheritDoc} 498 * @return the result of {@code defaultAction} 499 */ 500 @Override 501 public R visitNewClass(NewClassTree node, P p) { 502 return defaultAction(node, p); 503 } 504 505 /** 506 * {@inheritDoc} 507 * 508 * @implSpec This implementation calls {@code defaultAction}. 509 * 510 * @param node {@inheritDoc} 511 * @param p {@inheritDoc} 512 * @return the result of {@code defaultAction} 513 */ 514 @Override 515 public R visitNewArray(NewArrayTree node, P p) { 516 return defaultAction(node, p); 517 } 518 519 /** 520 * {@inheritDoc} 521 * 522 * @implSpec This implementation calls {@code defaultAction}. 523 * 524 * @param node {@inheritDoc} 525 * @param p {@inheritDoc} 526 * @return the result of {@code defaultAction} 527 */ 528 @Override 529 public R visitLambdaExpression(LambdaExpressionTree node, P p) { 530 return defaultAction(node, p); 531 } 532 533 /** 534 * {@inheritDoc} 535 * 536 * @implSpec This implementation calls {@code defaultAction}. 537 * 538 * @param node {@inheritDoc} 539 * @param p {@inheritDoc} 540 * @return the result of {@code defaultAction} 541 */ 542 @Override 543 public R visitParenthesized(ParenthesizedTree node, P p) { 544 return defaultAction(node, p); 545 } 546 547 /** 548 * {@inheritDoc} 549 * 550 * @implSpec This implementation calls {@code defaultAction}. 551 * 552 * @param node {@inheritDoc} 553 * @param p {@inheritDoc} 554 * @return the result of {@code defaultAction} 555 */ 556 @Override 557 public R visitAssignment(AssignmentTree node, P p) { 558 return defaultAction(node, p); 559 } 560 561 /** 562 * {@inheritDoc} 563 * 564 * @implSpec This implementation calls {@code defaultAction}. 565 * 566 * @param node {@inheritDoc} 567 * @param p {@inheritDoc} 568 * @return the result of {@code defaultAction} 569 */ 570 @Override 571 public R visitCompoundAssignment(CompoundAssignmentTree node, P p) { 572 return defaultAction(node, p); 573 } 574 575 /** 576 * {@inheritDoc} 577 * 578 * @implSpec This implementation calls {@code defaultAction}. 579 * 580 * @param node {@inheritDoc} 581 * @param p {@inheritDoc} 582 * @return the result of {@code defaultAction} 583 */ 584 @Override 585 public R visitUnary(UnaryTree node, P p) { 586 return defaultAction(node, p); 587 } 588 589 /** 590 * {@inheritDoc} 591 * 592 * @implSpec This implementation calls {@code defaultAction}. 593 * 594 * @param node {@inheritDoc} 595 * @param p {@inheritDoc} 596 * @return the result of {@code defaultAction} 597 */ 598 @Override 599 public R visitBinary(BinaryTree node, P p) { 600 return defaultAction(node, p); 601 } 602 603 /** 604 * {@inheritDoc} 605 * 606 * @implSpec This implementation calls {@code defaultAction}. 607 * 608 * @param node {@inheritDoc} 609 * @param p {@inheritDoc} 610 * @return the result of {@code defaultAction} 611 */ 612 @Override 613 public R visitTypeCast(TypeCastTree node, P p) { 614 return defaultAction(node, p); 615 } 616 617 /** 618 * {@inheritDoc} 619 * 620 * @implSpec This implementation calls {@code defaultAction}. 621 * 622 * @param node {@inheritDoc} 623 * @param p {@inheritDoc} 624 * @return the result of {@code defaultAction} 625 */ 626 @Override 627 public R visitInstanceOf(InstanceOfTree node, P p) { 628 return defaultAction(node, p); 629 } 630 631 /** 632 * {@inheritDoc} 633 * 634 * @implSpec This implementation calls {@code defaultAction}. 635 * 636 * @param node {@inheritDoc} 637 * @param p {@inheritDoc} 638 * @return the result of {@code defaultAction} 639 * @since 14 640 */ 641 @Override 642 public R visitBindingPattern(BindingPatternTree node, P p) { 643 return defaultAction(node, p); 644 } 645 646 /** 647 * {@inheritDoc} 648 * 649 * @implSpec This implementation calls {@code defaultAction}. 650 * 651 * @param node {@inheritDoc} 652 * @param p {@inheritDoc} 653 * @return the result of {@code defaultAction} 654 * @since 17 655 */ 656 @Override 657 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true) 658 public R visitDefaultCaseLabel(DefaultCaseLabelTree node, P p) { 659 return defaultAction(node, p); 660 } 661 662 /** 663 * {@inheritDoc} 664 * 665 * @implSpec This implementation calls {@code defaultAction}. 666 * 667 * @param node {@inheritDoc} 668 * @param p {@inheritDoc} 669 * @return the result of {@code defaultAction} 670 */ 671 @Override 672 public R visitArrayAccess(ArrayAccessTree node, P p) { 673 return defaultAction(node, p); 674 } 675 676 /** 677 * {@inheritDoc} 678 * 679 * @implSpec This implementation calls {@code defaultAction}. 680 * 681 * @param node {@inheritDoc} 682 * @param p {@inheritDoc} 683 * @return the result of {@code defaultAction} 684 */ 685 @Override 686 public R visitMemberSelect(MemberSelectTree node, P p) { 687 return defaultAction(node, p); 688 } 689 690 /** 691 * {@inheritDoc} 692 * 693 * @implSpec This implementation calls {@code defaultAction}. 694 * 695 * @param node {@inheritDoc} 696 * @param p {@inheritDoc} 697 * @return the result of {@code defaultAction} 698 * @since 17 699 */ 700 @Override 701 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true) 702 public R visitParenthesizedPattern(ParenthesizedPatternTree node, P p) { 703 return defaultAction(node, p); 704 } 705 706 /** 707 * {@inheritDoc} 708 * 709 * @implSpec This implementation calls {@code defaultAction}. 710 * 711 * @param node {@inheritDoc} 712 * @param p {@inheritDoc} 713 * @return the result of {@code defaultAction} 714 * @since 17 715 */ 716 @Override 717 @PreviewFeature(feature=PreviewFeature.Feature.SWITCH_PATTERN_MATCHING, reflective=true) 718 public R visitGuardedPattern(GuardedPatternTree node, P p) { 719 return defaultAction(node, p); 720 } 721 722 /** 723 * {@inheritDoc} 724 * 725 * @implSpec This implementation calls {@code defaultAction}. 726 * 727 * @param node {@inheritDoc} 728 * @param p {@inheritDoc} 729 * @return the result of {@code defaultAction} 730 */ 731 @Override 732 public R visitMemberReference(MemberReferenceTree node, P p) { 733 return defaultAction(node, p); 734 } 735 736 /** 737 * {@inheritDoc} 738 * 739 * @implSpec This implementation calls {@code defaultAction}. 740 * 741 * @param node {@inheritDoc} 742 * @param p {@inheritDoc} 743 * @return the result of {@code defaultAction} 744 */ 745 @Override 746 public R visitIdentifier(IdentifierTree node, P p) { 747 return defaultAction(node, p); 748 } 749 750 /** 751 * {@inheritDoc} 752 * 753 * @implSpec This implementation calls {@code defaultAction}. 754 * 755 * @param node {@inheritDoc} 756 * @param p {@inheritDoc} 757 * @return the result of {@code defaultAction} 758 */ 759 @Override 760 public R visitLiteral(LiteralTree node, P p) { 761 return defaultAction(node, p); 762 } 763 764 /** 765 * {@inheritDoc} 766 * 767 * @implSpec This implementation calls {@code defaultAction}. 768 * 769 * @param node {@inheritDoc} 770 * @param p {@inheritDoc} 771 * @return the result of {@code defaultAction} 772 */ 773 @Override 774 public R visitPrimitiveType(PrimitiveTypeTree node, P p) { 775 return defaultAction(node, p); 776 } 777 778 /** 779 * {@inheritDoc} 780 * 781 * @implSpec This implementation calls {@code defaultAction}. 782 * 783 * @param node {@inheritDoc} 784 * @param p {@inheritDoc} 785 * @return the result of {@code defaultAction} 786 */ 787 @Override 788 public R visitArrayType(ArrayTypeTree node, P p) { 789 return defaultAction(node, p); 790 } 791 792 /** 793 * {@inheritDoc} 794 * 795 * @implSpec This implementation calls {@code defaultAction}. 796 * 797 * @param node {@inheritDoc} 798 * @param p {@inheritDoc} 799 * @return the result of {@code defaultAction} 800 */ 801 @Override 802 public R visitParameterizedType(ParameterizedTypeTree node, P p) { 803 return defaultAction(node, p); 804 } 805 806 /** 807 * {@inheritDoc} 808 * 809 * @implSpec This implementation calls {@code defaultAction}. 810 * 811 * @param node {@inheritDoc} 812 * @param p {@inheritDoc} 813 * @return the result of {@code defaultAction} 814 */ 815 @Override 816 public R visitUnionType(UnionTypeTree node, P p) { 817 return defaultAction(node, p); 818 } 819 820 /** 821 * {@inheritDoc} 822 * 823 * @implSpec This implementation calls {@code defaultAction}. 824 * 825 * @param node {@inheritDoc} 826 * @param p {@inheritDoc} 827 * @return the result of {@code defaultAction} 828 */ 829 @Override 830 public R visitIntersectionType(IntersectionTypeTree node, P p) { 831 return defaultAction(node, p); 832 } 833 834 /** 835 * {@inheritDoc} 836 * 837 * @implSpec This implementation calls {@code defaultAction}. 838 * 839 * @param node {@inheritDoc} 840 * @param p {@inheritDoc} 841 * @return the result of {@code defaultAction} 842 */ 843 @Override 844 public R visitTypeParameter(TypeParameterTree node, P p) { 845 return defaultAction(node, p); 846 } 847 848 /** 849 * {@inheritDoc} 850 * 851 * @implSpec This implementation calls {@code defaultAction}. 852 * 853 * @param node {@inheritDoc} 854 * @param p {@inheritDoc} 855 * @return the result of {@code defaultAction} 856 */ 857 @Override 858 public R visitWildcard(WildcardTree node, P p) { 859 return defaultAction(node, p); 860 } 861 862 /** 863 * {@inheritDoc} 864 * 865 * @implSpec This implementation calls {@code defaultAction}. 866 * 867 * @param node {@inheritDoc} 868 * @param p {@inheritDoc} 869 * @return the result of {@code defaultAction} 870 */ 871 @Override 872 public R visitModifiers(ModifiersTree node, P p) { 873 return defaultAction(node, p); 874 } 875 876 /** 877 * {@inheritDoc} 878 * 879 * @implSpec This implementation calls {@code defaultAction}. 880 * 881 * @param node {@inheritDoc} 882 * @param p {@inheritDoc} 883 * @return the result of {@code defaultAction} 884 */ 885 @Override 886 public R visitAnnotation(AnnotationTree node, P p) { 887 return defaultAction(node, p); 888 } 889 890 /** 891 * {@inheritDoc} 892 * 893 * @implSpec This implementation calls {@code defaultAction}. 894 * 895 * @param node {@inheritDoc} 896 * @param p {@inheritDoc} 897 * @return the result of {@code defaultAction} 898 */ 899 @Override 900 public R visitAnnotatedType(AnnotatedTypeTree node, P p) { 901 return defaultAction(node, p); 902 } 903 904 /** 905 * {@inheritDoc} 906 * 907 * @implSpec This implementation calls {@code defaultAction}. 908 * 909 * @param node {@inheritDoc} 910 * @param p {@inheritDoc} 911 * @return the result of {@code defaultAction} 912 */ 913 @Override 914 public R visitModule(ModuleTree node, P p) { 915 return defaultAction(node, p); 916 } 917 918 /** 919 * {@inheritDoc} 920 * 921 * @implSpec This implementation calls {@code defaultAction}. 922 * 923 * @param node {@inheritDoc} 924 * @param p {@inheritDoc} 925 * @return the result of {@code defaultAction} 926 */ 927 @Override 928 public R visitExports(ExportsTree node, P p) { 929 return defaultAction(node, p); 930 } 931 932 /** 933 * {@inheritDoc} 934 * 935 * @implSpec This implementation calls {@code defaultAction}. 936 * 937 * @param node {@inheritDoc} 938 * @param p {@inheritDoc} 939 * @return the result of {@code defaultAction} 940 */ 941 @Override 942 public R visitOpens(OpensTree node, P p) { 943 return defaultAction(node, p); 944 } 945 946 /** 947 * {@inheritDoc} 948 * 949 * @implSpec This implementation calls {@code defaultAction}. 950 * 951 * @param node {@inheritDoc} 952 * @param p {@inheritDoc} 953 * @return the result of {@code defaultAction} 954 */ 955 @Override 956 public R visitProvides(ProvidesTree node, P p) { 957 return defaultAction(node, p); 958 } 959 960 /** 961 * {@inheritDoc} 962 * 963 * @implSpec This implementation calls {@code defaultAction}. 964 * 965 * @param node {@inheritDoc} 966 * @param p {@inheritDoc} 967 * @return the result of {@code defaultAction} 968 */ 969 @Override 970 public R visitRequires(RequiresTree node, P p) { 971 return defaultAction(node, p); 972 } 973 974 /** 975 * {@inheritDoc} 976 * 977 * @implSpec This implementation calls {@code defaultAction}. 978 * 979 * @param node {@inheritDoc} 980 * @param p {@inheritDoc} 981 * @return the result of {@code defaultAction} 982 */ 983 @Override 984 public R visitUses(UsesTree node, P p) { 985 return defaultAction(node, p); 986 } 987 988 /** 989 * {@inheritDoc} 990 * 991 * @implSpec This implementation calls {@code defaultAction}. 992 * 993 * @param node {@inheritDoc} 994 * @param p {@inheritDoc} 995 * @return the result of {@code defaultAction} 996 */ 997 @Override 998 public R visitErroneous(ErroneousTree node, P p) { 999 return defaultAction(node, p); 1000 } 1001 1002 /** 1003 * {@inheritDoc} 1004 * 1005 * @implSpec This implementation calls {@code defaultAction}. 1006 * 1007 * @param node {@inheritDoc} 1008 * @param p {@inheritDoc} 1009 * @return the result of {@code defaultAction} 1010 */ 1011 @Override 1012 public R visitOther(Tree node, P p) { 1013 return defaultAction(node, p); 1014 } 1015 1016 /** 1017 * {@inheritDoc} 1018 * 1019 * @implSpec This implementation calls {@code defaultAction}. 1020 * 1021 * @param node {@inheritDoc} 1022 * @param p {@inheritDoc} 1023 * @return the result of {@code defaultAction} 1024 */ 1025 @Override 1026 public R visitYield(YieldTree node, P p) { 1027 return defaultAction(node, p); 1028 } 1029 }