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 30 /** 31 * A simple visitor for tree nodes. 32 * 33 * @param <R> the return type of this visitor's methods. Use {@link 34 * Void} for visitors that do not need to return results. 35 * @param <P> the type of the additional parameter to this visitor's 36 * methods. Use {@code Void} for visitors that do not need an 37 * additional parameter. 38 * 39 * @author Peter von der Ahé 40 * @since 1.6 41 */ 42 public class SimpleTreeVisitor <R,P> implements TreeVisitor<R,P> { 43 /** 44 * The default value, returned by the {@link #defaultAction default action}. 45 */ 46 protected final R DEFAULT_VALUE; 47 48 /** 49 * Creates a visitor, with a DEFAULT_VALUE of {@code null}. 50 */ 51 protected SimpleTreeVisitor() { 52 DEFAULT_VALUE = null; 53 } 54 55 /** 56 * Creates a visitor, with a specified DEFAULT_VALUE. 57 * @param defaultValue the default value to be returned by the default action 58 */ 59 protected SimpleTreeVisitor(R defaultValue) { 60 DEFAULT_VALUE = defaultValue; 61 } 62 63 /** 64 * The default action, used by all visit methods that are not overridden. 65 * @param node the node being visited 66 * @param p the parameter value passed to the visit method 67 * @return the result value to be returned from the visit method 68 */ 69 protected R defaultAction(Tree node, P p) { 70 return DEFAULT_VALUE; 71 } 72 73 /** 74 * Invokes the appropriate visit method specific to the type of the node. 75 * @param node the node on which to dispatch 76 * @param p a parameter to be passed to the appropriate visit method 77 * @return the value returns from the appropriate visit method 78 */ 79 public final R visit(Tree node, P p) { 80 return (node == null) ? null : node.accept(this, p); 81 } 82 83 /** 84 * Invokes the appropriate visit method on each of a sequence of nodes. 85 * @param nodes the nodes on which to dispatch 86 * @param p a parameter value to be passed to each appropriate visit method 87 * @return the value return from the last of the visit methods, or null 88 * if none were called 89 */ 90 public final R visit(Iterable<? extends Tree> nodes, P p) { 91 R r = null; 92 if (nodes != null) 93 for (Tree node : nodes) 94 r = visit(node, p); 95 return r; 96 } 97 98 /** 99 * {@inheritDoc} 100 * 101 * @implSpec This implementation calls {@code defaultAction}. 102 * 103 * @param node {@inheritDoc} 104 * @param p {@inheritDoc} 105 * @return the result of {@code defaultAction} 106 */ 107 @Override 108 public R visitCompilationUnit(CompilationUnitTree node, P p) { 109 return defaultAction(node, p); 110 } 111 112 /** 113 * {@inheritDoc} 114 * 115 * @implSpec This implementation calls {@code defaultAction}. 116 * 117 * @param node {@inheritDoc} 118 * @param p {@inheritDoc} 119 * @return the result of {@code defaultAction} 120 */ 121 @Override 122 public R visitPackage(PackageTree node, P p) { 123 return defaultAction(node, p); 124 } 125 126 /** 127 * {@inheritDoc} 128 * 129 * @implSpec This implementation calls {@code defaultAction}. 130 * 131 * @param node {@inheritDoc} 132 * @param p {@inheritDoc} 133 * @return the result of {@code defaultAction} 134 */ 135 @Override 136 public R visitImport(ImportTree node, P p) { 137 return defaultAction(node, p); 138 } 139 140 /** 141 * {@inheritDoc} 142 * 143 * @implSpec This implementation calls {@code defaultAction}. 144 * 145 * @param node {@inheritDoc} 146 * @param p {@inheritDoc} 147 * @return the result of {@code defaultAction} 148 */ 149 @Override 150 public R visitClass(ClassTree node, P p) { 151 return defaultAction(node, p); 152 } 153 154 /** 155 * {@inheritDoc} 156 * 157 * @implSpec This implementation calls {@code defaultAction}. 158 * 159 * @param node {@inheritDoc} 160 * @param p {@inheritDoc} 161 * @return the result of {@code defaultAction} 162 */ 163 @Override 164 public R visitMethod(MethodTree node, P p) { 165 return defaultAction(node, p); 166 } 167 168 /** 169 * {@inheritDoc} 170 * 171 * @implSpec This implementation calls {@code defaultAction}. 172 * 173 * @param node {@inheritDoc} 174 * @param p {@inheritDoc} 175 * @return the result of {@code defaultAction} 176 */ 177 @Override 178 public R visitVariable(VariableTree node, P p) { 179 return defaultAction(node, p); 180 } 181 182 /** 183 * {@inheritDoc} 184 * 185 * @implSpec This implementation calls {@code defaultAction}. 186 * 187 * @param node {@inheritDoc} 188 * @param p {@inheritDoc} 189 * @return the result of {@code defaultAction} 190 */ 191 @Override 192 public R visitEmptyStatement(EmptyStatementTree node, P p) { 193 return defaultAction(node, p); 194 } 195 196 /** 197 * {@inheritDoc} 198 * 199 * @implSpec This implementation calls {@code defaultAction}. 200 * 201 * @param node {@inheritDoc} 202 * @param p {@inheritDoc} 203 * @return the result of {@code defaultAction} 204 */ 205 @Override 206 public R visitBlock(BlockTree node, P p) { 207 return defaultAction(node, p); 208 } 209 210 /** 211 * {@inheritDoc} 212 * 213 * @implSpec This implementation calls {@code defaultAction}. 214 * 215 * @param node {@inheritDoc} 216 * @param p {@inheritDoc} 217 * @return the result of {@code defaultAction} 218 */ 219 @Override 220 public R visitDoWhileLoop(DoWhileLoopTree node, P p) { 221 return defaultAction(node, p); 222 } 223 224 /** 225 * {@inheritDoc} 226 * 227 * @implSpec This implementation calls {@code defaultAction}. 228 * 229 * @param node {@inheritDoc} 230 * @param p {@inheritDoc} 231 * @return the result of {@code defaultAction} 232 */ 233 @Override 234 public R visitWhileLoop(WhileLoopTree node, P p) { 235 return defaultAction(node, p); 236 } 237 238 /** 239 * {@inheritDoc} 240 * 241 * @implSpec This implementation calls {@code defaultAction}. 242 * 243 * @param node {@inheritDoc} 244 * @param p {@inheritDoc} 245 * @return the result of {@code defaultAction} 246 */ 247 @Override 248 public R visitForLoop(ForLoopTree node, P p) { 249 return defaultAction(node, p); 250 } 251 252 /** 253 * {@inheritDoc} 254 * 255 * @implSpec This implementation calls {@code defaultAction}. 256 * 257 * @param node {@inheritDoc} 258 * @param p {@inheritDoc} 259 * @return the result of {@code defaultAction} 260 */ 261 @Override 262 public R visitEnhancedForLoop(EnhancedForLoopTree node, P p) { 263 return defaultAction(node, p); 264 } 265 266 /** 267 * {@inheritDoc} 268 * 269 * @implSpec This implementation calls {@code defaultAction}. 270 * 271 * @param node {@inheritDoc} 272 * @param p {@inheritDoc} 273 * @return the result of {@code defaultAction} 274 */ 275 @Override 276 public R visitLabeledStatement(LabeledStatementTree node, P p) { 277 return defaultAction(node, p); 278 } 279 280 /** 281 * {@inheritDoc} 282 * 283 * @implSpec This implementation calls {@code defaultAction}. 284 * 285 * @param node {@inheritDoc} 286 * @param p {@inheritDoc} 287 * @return the result of {@code defaultAction} 288 */ 289 @Override 290 public R visitSwitch(SwitchTree node, P p) { 291 return defaultAction(node, p); 292 } 293 294 /** 295 * {@inheritDoc} 296 * 297 * @implSpec This implementation calls {@code defaultAction}. 298 * 299 * @param node {@inheritDoc} 300 * @param p {@inheritDoc} 301 * @return the result of {@code defaultAction} 302 * 303 * @since 14 304 */ 305 @Override 306 public R visitSwitchExpression(SwitchExpressionTree node, P p) { 307 return defaultAction(node, p); 308 } 309 310 /** 311 * {@inheritDoc} 312 * 313 * @implSpec This implementation calls {@code defaultAction}. 314 * 315 * @param node {@inheritDoc} 316 * @param p {@inheritDoc} 317 * @return the result of {@code defaultAction} 318 */ 319 @Override 320 public R visitCase(CaseTree node, P p) { 321 return defaultAction(node, p); 322 } 323 324 /** 325 * {@inheritDoc} 326 * 327 * @implSpec This implementation calls {@code defaultAction}. 328 * 329 * @param node {@inheritDoc} 330 * @param p {@inheritDoc} 331 * @return the result of {@code defaultAction} 332 */ 333 @Override 334 public R visitSynchronized(SynchronizedTree node, P p) { 335 return defaultAction(node, p); 336 } 337 338 /** 339 * {@inheritDoc} 340 * 341 * @implSpec This implementation calls {@code defaultAction}. 342 * 343 * @param node {@inheritDoc} 344 * @param p {@inheritDoc} 345 * @return the result of {@code defaultAction} 346 */ 347 @Override 348 public R visitTry(TryTree node, P p) { 349 return defaultAction(node, p); 350 } 351 352 /** 353 * {@inheritDoc} 354 * 355 * @implSpec This implementation calls {@code defaultAction}. 356 * 357 * @param node {@inheritDoc} 358 * @param p {@inheritDoc} 359 * @return the result of {@code defaultAction} 360 */ 361 @Override 362 public R visitCatch(CatchTree node, P p) { 363 return defaultAction(node, p); 364 } 365 366 /** 367 * {@inheritDoc} 368 * 369 * @implSpec This implementation calls {@code defaultAction}. 370 * 371 * @param node {@inheritDoc} 372 * @param p {@inheritDoc} 373 * @return the result of {@code defaultAction} 374 */ 375 @Override 376 public R visitConditionalExpression(ConditionalExpressionTree node, P p) { 377 return defaultAction(node, p); 378 } 379 380 /** 381 * {@inheritDoc} 382 * 383 * @implSpec This implementation calls {@code defaultAction}. 384 * 385 * @param node {@inheritDoc} 386 * @param p {@inheritDoc} 387 * @return the result of {@code defaultAction} 388 */ 389 @Override 390 public R visitIf(IfTree node, P p) { 391 return defaultAction(node, p); 392 } 393 394 /** 395 * {@inheritDoc} 396 * 397 * @implSpec This implementation calls {@code defaultAction}. 398 * 399 * @param node {@inheritDoc} 400 * @param p {@inheritDoc} 401 * @return the result of {@code defaultAction} 402 */ 403 @Override 404 public R visitExpressionStatement(ExpressionStatementTree node, P p) { 405 return defaultAction(node, p); 406 } 407 408 /** 409 * {@inheritDoc} 410 * 411 * @implSpec This implementation calls {@code defaultAction}. 412 * 413 * @param node {@inheritDoc} 414 * @param p {@inheritDoc} 415 * @return the result of {@code defaultAction} 416 */ 417 @Override 418 public R visitBreak(BreakTree node, P p) { 419 return defaultAction(node, p); 420 } 421 422 /** 423 * {@inheritDoc} 424 * 425 * @implSpec This implementation calls {@code defaultAction}. 426 * 427 * @param node {@inheritDoc} 428 * @param p {@inheritDoc} 429 * @return the result of {@code defaultAction} 430 */ 431 @Override 432 public R visitContinue(ContinueTree node, P p) { 433 return defaultAction(node, p); 434 } 435 436 /** 437 * {@inheritDoc} 438 * 439 * @implSpec This implementation calls {@code defaultAction}. 440 * 441 * @param node {@inheritDoc} 442 * @param p {@inheritDoc} 443 * @return the result of {@code defaultAction} 444 */ 445 @Override 446 public R visitReturn(ReturnTree node, P p) { 447 return defaultAction(node, p); 448 } 449 450 /** 451 * {@inheritDoc} 452 * 453 * @implSpec This implementation calls {@code defaultAction}. 454 * 455 * @param node {@inheritDoc} 456 * @param p {@inheritDoc} 457 * @return the result of {@code defaultAction} 458 */ 459 @Override 460 public R visitThrow(ThrowTree node, P p) { 461 return defaultAction(node, p); 462 } 463 464 /** 465 * {@inheritDoc} 466 * 467 * @implSpec This implementation calls {@code defaultAction}. 468 * 469 * @param node {@inheritDoc} 470 * @param p {@inheritDoc} 471 * @return the result of {@code defaultAction} 472 */ 473 @Override 474 public R visitAssert(AssertTree node, P p) { 475 return defaultAction(node, p); 476 } 477 478 /** 479 * {@inheritDoc} 480 * 481 * @implSpec This implementation calls {@code defaultAction}. 482 * 483 * @param node {@inheritDoc} 484 * @param p {@inheritDoc} 485 * @return the result of {@code defaultAction} 486 */ 487 @Override 488 public R visitMethodInvocation(MethodInvocationTree node, P p) { 489 return defaultAction(node, p); 490 } 491 492 /** 493 * {@inheritDoc} 494 * 495 * @implSpec This implementation calls {@code defaultAction}. 496 * 497 * @param node {@inheritDoc} 498 * @param p {@inheritDoc} 499 * @return the result of {@code defaultAction} 500 */ 501 @Override 502 public R visitNewClass(NewClassTree node, P p) { 503 return defaultAction(node, p); 504 } 505 506 /** 507 * {@inheritDoc} 508 * 509 * @implSpec This implementation calls {@code defaultAction}. 510 * 511 * @param node {@inheritDoc} 512 * @param p {@inheritDoc} 513 * @return the result of {@code defaultAction} 514 */ 515 @Override 516 public R visitNewArray(NewArrayTree node, P p) { 517 return defaultAction(node, p); 518 } 519 520 /** 521 * {@inheritDoc} 522 * 523 * @implSpec This implementation calls {@code defaultAction}. 524 * 525 * @param node {@inheritDoc} 526 * @param p {@inheritDoc} 527 * @return the result of {@code defaultAction} 528 */ 529 @Override 530 public R visitLambdaExpression(LambdaExpressionTree node, P p) { 531 return defaultAction(node, p); 532 } 533 534 /** 535 * {@inheritDoc} 536 * 537 * @implSpec This implementation calls {@code defaultAction}. 538 * 539 * @param node {@inheritDoc} 540 * @param p {@inheritDoc} 541 * @return the result of {@code defaultAction} 542 */ 543 @Override 544 public R visitParenthesized(ParenthesizedTree node, P p) { 545 return defaultAction(node, p); 546 } 547 548 /** 549 * {@inheritDoc} 550 * 551 * @implSpec This implementation calls {@code defaultAction}. 552 * 553 * @param node {@inheritDoc} 554 * @param p {@inheritDoc} 555 * @return the result of {@code defaultAction} 556 */ 557 @Override 558 public R visitAssignment(AssignmentTree node, P p) { 559 return defaultAction(node, p); 560 } 561 562 /** 563 * {@inheritDoc} 564 * 565 * @implSpec This implementation calls {@code defaultAction}. 566 * 567 * @param node {@inheritDoc} 568 * @param p {@inheritDoc} 569 * @return the result of {@code defaultAction} 570 */ 571 @Override 572 public R visitCompoundAssignment(CompoundAssignmentTree node, P p) { 573 return defaultAction(node, p); 574 } 575 576 /** 577 * {@inheritDoc} 578 * 579 * @implSpec This implementation calls {@code defaultAction}. 580 * 581 * @param node {@inheritDoc} 582 * @param p {@inheritDoc} 583 * @return the result of {@code defaultAction} 584 */ 585 @Override 586 public R visitUnary(UnaryTree node, P p) { 587 return defaultAction(node, p); 588 } 589 590 /** 591 * {@inheritDoc} 592 * 593 * @implSpec This implementation calls {@code defaultAction}. 594 * 595 * @param node {@inheritDoc} 596 * @param p {@inheritDoc} 597 * @return the result of {@code defaultAction} 598 */ 599 @Override 600 public R visitBinary(BinaryTree node, P p) { 601 return defaultAction(node, p); 602 } 603 604 /** 605 * {@inheritDoc} 606 * 607 * @implSpec This implementation calls {@code defaultAction}. 608 * 609 * @param node {@inheritDoc} 610 * @param p {@inheritDoc} 611 * @return the result of {@code defaultAction} 612 */ 613 @Override 614 public R visitTypeCast(TypeCastTree node, P p) { 615 return defaultAction(node, p); 616 } 617 618 /** 619 * {@inheritDoc} 620 * 621 * @implSpec This implementation calls {@code defaultAction}. 622 * 623 * @param node {@inheritDoc} 624 * @param p {@inheritDoc} 625 * @return the result of {@code defaultAction} 626 */ 627 @Override 628 public R visitInstanceOf(InstanceOfTree node, P p) { 629 return defaultAction(node, p); 630 } 631 632 /** 633 * {@inheritDoc} 634 * 635 * @implSpec This implementation calls {@code defaultAction}. 636 * 637 * @param node {@inheritDoc} 638 * @param p {@inheritDoc} 639 * @return the result of {@code defaultAction} 640 * @since 22 641 */ 642 @Override 643 public R visitAnyPattern(AnyPatternTree node, P p) { 644 return defaultAction(node, p); 645 } 646 647 /** 648 * {@inheritDoc} 649 * 650 * @implSpec This implementation calls {@code defaultAction}. 651 * 652 * @param node {@inheritDoc} 653 * @param p {@inheritDoc} 654 * @return the result of {@code defaultAction} 655 * @since 14 656 */ 657 @Override 658 public R visitBindingPattern(BindingPatternTree 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 * @since 21 671 */ 672 @Override 673 public R visitDefaultCaseLabel(DefaultCaseLabelTree node, P p) { 674 return defaultAction(node, p); 675 } 676 677 /** 678 * {@inheritDoc} 679 * 680 * @implSpec This implementation calls {@code defaultAction}. 681 * 682 * @param node {@inheritDoc} 683 * @param p {@inheritDoc} 684 * @return the result of {@code defaultAction} 685 * @since 21 686 */ 687 @Override 688 public R visitConstantCaseLabel(ConstantCaseLabelTree node, P p) { 689 return defaultAction(node, p); 690 } 691 692 /** 693 * {@inheritDoc} 694 * 695 * @implSpec This implementation calls {@code defaultAction}. 696 * 697 * @param node {@inheritDoc} 698 * @param p {@inheritDoc} 699 * @return the result of {@code defaultAction} 700 * @since 21 701 */ 702 @Override 703 public R visitDeconstructionPattern(DeconstructionPatternTree node, P p) { 704 return defaultAction(node, p); 705 } 706 707 /** 708 * {@inheritDoc} 709 * 710 * @implSpec This implementation calls {@code defaultAction}. 711 * 712 * @param node {@inheritDoc} 713 * @param p {@inheritDoc} 714 * @return the result of {@code defaultAction} 715 * @since 21 716 */ 717 @Override 718 public R visitPatternCaseLabel(PatternCaseLabelTree 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 visitArrayAccess(ArrayAccessTree 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 visitMemberSelect(MemberSelectTree 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 visitMemberReference(MemberReferenceTree 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 visitIdentifier(IdentifierTree 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 visitLiteral(LiteralTree 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 visitPrimitiveType(PrimitiveTypeTree 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 visitArrayType(ArrayTypeTree 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 visitParameterizedType(ParameterizedTypeTree 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 visitUnionType(UnionTypeTree 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 visitIntersectionType(IntersectionTypeTree 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 visitTypeParameter(TypeParameterTree 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 visitWildcard(WildcardTree 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 visitModifiers(ModifiersTree 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 visitAnnotation(AnnotationTree 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 visitAnnotatedType(AnnotatedTypeTree 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 visitModule(ModuleTree 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 visitExports(ExportsTree 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 visitOpens(OpensTree 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 visitProvides(ProvidesTree 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 visitRequires(RequiresTree 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 visitUses(UsesTree 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 visitErroneous(ErroneousTree node, P p) { 1027 return defaultAction(node, p); 1028 } 1029 1030 /** 1031 * {@inheritDoc} 1032 * 1033 * @implSpec This implementation calls {@code defaultAction}. 1034 * 1035 * @param node {@inheritDoc} 1036 * @param p {@inheritDoc} 1037 * @return the result of {@code defaultAction} 1038 */ 1039 @Override 1040 public R visitOther(Tree node, P p) { 1041 return defaultAction(node, p); 1042 } 1043 1044 /** 1045 * {@inheritDoc} 1046 * 1047 * @implSpec This implementation calls {@code defaultAction}. 1048 * 1049 * @param node {@inheritDoc} 1050 * @param p {@inheritDoc} 1051 * @return the result of {@code defaultAction} 1052 * 1053 * @since 14 1054 */ 1055 @Override 1056 public R visitYield(YieldTree node, P p) { 1057 return defaultAction(node, p); 1058 } 1059 }