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 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&eacute;
  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} This implementation calls {@code defaultAction}.
 100      *
 101      * @param node {@inheritDoc}
 102      * @param p {@inheritDoc}
 103      * @return  the result of {@code defaultAction}
 104      */
 105     @Override
 106     public R visitCompilationUnit(CompilationUnitTree node, P p) {
 107         return defaultAction(node, p);
 108     }
 109 
 110     /**
 111      * {@inheritDoc} This implementation calls {@code defaultAction}.
 112      *
 113      * @param node {@inheritDoc}
 114      * @param p {@inheritDoc}
 115      * @return  the result of {@code defaultAction}
 116      */
 117     @Override
 118     public R visitPackage(PackageTree node, P p) {
 119         return defaultAction(node, p);
 120     }
 121 
 122     /**
 123      * {@inheritDoc} This implementation calls {@code defaultAction}.
 124      *
 125      * @param node {@inheritDoc}
 126      * @param p {@inheritDoc}
 127      * @return  the result of {@code defaultAction}
 128      */
 129     @Override
 130     public R visitImport(ImportTree node, P p) {
 131         return defaultAction(node, p);
 132     }
 133 
 134     /**
 135      * {@inheritDoc} This implementation calls {@code defaultAction}.
 136      *
 137      * @param node {@inheritDoc}
 138      * @param p {@inheritDoc}
 139      * @return  the result of {@code defaultAction}
 140      */
 141     @Override
 142     public R visitClass(ClassTree node, P p) {
 143         return defaultAction(node, p);
 144     }
 145 
 146     /**
 147      * {@inheritDoc} This implementation calls {@code defaultAction}.
 148      *
 149      * @param node {@inheritDoc}
 150      * @param p {@inheritDoc}
 151      * @return  the result of {@code defaultAction}
 152      */
 153     @Override
 154     public R visitMethod(MethodTree node, P p) {
 155         return defaultAction(node, p);
 156     }
 157 
 158     /**
 159      * {@inheritDoc} This implementation calls {@code defaultAction}.
 160      *
 161      * @param node {@inheritDoc}
 162      * @param p {@inheritDoc}
 163      * @return  the result of {@code defaultAction}
 164      */
 165     @Override
 166     public R visitVariable(VariableTree node, P p) {
 167         return defaultAction(node, p);
 168     }
 169 
 170     /**
 171      * {@inheritDoc} 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 visitEmptyStatement(EmptyStatementTree node, P p) {
 179         return defaultAction(node, p);
 180     }
 181 
 182     /**
 183      * {@inheritDoc} This implementation calls {@code defaultAction}.
 184      *
 185      * @param node {@inheritDoc}
 186      * @param p {@inheritDoc}
 187      * @return  the result of {@code defaultAction}
 188      */
 189     @Override
 190     public R visitBlock(BlockTree node, P p) {
 191         return defaultAction(node, p);
 192     }
 193 
 194     /**
 195      * {@inheritDoc} This implementation calls {@code defaultAction}.
 196      *
 197      * @param node {@inheritDoc}
 198      * @param p {@inheritDoc}
 199      * @return  the result of {@code defaultAction}
 200      */
 201     @Override
 202     public R visitDoWhileLoop(DoWhileLoopTree node, P p) {
 203         return defaultAction(node, p);
 204     }
 205 
 206     /**
 207      * {@inheritDoc} This implementation calls {@code defaultAction}.
 208      *
 209      * @param node {@inheritDoc}
 210      * @param p {@inheritDoc}
 211      * @return  the result of {@code defaultAction}
 212      */
 213     @Override
 214     public R visitWhileLoop(WhileLoopTree node, P p) {
 215         return defaultAction(node, p);
 216     }
 217 
 218     /**
 219      * {@inheritDoc} This implementation calls {@code defaultAction}.
 220      *
 221      * @param node {@inheritDoc}
 222      * @param p {@inheritDoc}
 223      * @return  the result of {@code defaultAction}
 224      */
 225     @Override
 226     public R visitForLoop(ForLoopTree node, P p) {
 227         return defaultAction(node, p);
 228     }
 229 
 230     /**
 231      * {@inheritDoc} This implementation calls {@code defaultAction}.
 232      *
 233      * @param node {@inheritDoc}
 234      * @param p {@inheritDoc}
 235      * @return  the result of {@code defaultAction}
 236      */
 237     @Override
 238     public R visitEnhancedForLoop(EnhancedForLoopTree node, P p) {
 239         return defaultAction(node, p);
 240     }
 241 
 242     /**
 243      * {@inheritDoc} This implementation calls {@code defaultAction}.
 244      *
 245      * @param node {@inheritDoc}
 246      * @param p {@inheritDoc}
 247      * @return  the result of {@code defaultAction}
 248      */
 249     @Override
 250     public R visitLabeledStatement(LabeledStatementTree node, P p) {
 251         return defaultAction(node, p);
 252     }
 253 
 254     /**
 255      * {@inheritDoc} 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 visitSwitch(SwitchTree node, P p) {
 263         return defaultAction(node, p);
 264     }
 265 
 266     /**
 267      * {@inheritDoc} This implementation calls {@code defaultAction}.
 268      *
 269      * @param node {@inheritDoc}
 270      * @param p {@inheritDoc}
 271      * @return  the result of {@code defaultAction}
 272      *
 273      * @deprecated
 274      * This method is modeling switch expressions,
 275      * which are part of a preview feature and may be removed
 276      * if the preview feature is removed.
 277      */
 278     @Override
 279     @Deprecated(forRemoval=true, since="12")
 280     @SuppressWarnings("removal")
 281     public R visitSwitchExpression(SwitchExpressionTree node, P p) {
 282         return defaultAction(node, p);
 283     }
 284 
 285     /**
 286      * {@inheritDoc} This implementation calls {@code defaultAction}.
 287      *
 288      * @param node {@inheritDoc}
 289      * @param p {@inheritDoc}
 290      * @return  the result of {@code defaultAction}
 291      */
 292     @Override
 293     public R visitCase(CaseTree node, P p) {
 294         return defaultAction(node, p);
 295     }
 296 
 297     /**
 298      * {@inheritDoc} 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 visitSynchronized(SynchronizedTree node, P p) {
 306         return defaultAction(node, p);
 307     }
 308 
 309     /**
 310      * {@inheritDoc} 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 visitTry(TryTree node, P p) {
 318         return defaultAction(node, p);
 319     }
 320 
 321     /**
 322      * {@inheritDoc} This implementation calls {@code defaultAction}.
 323      *
 324      * @param node {@inheritDoc}
 325      * @param p {@inheritDoc}
 326      * @return  the result of {@code defaultAction}
 327      */
 328     @Override
 329     public R visitCatch(CatchTree node, P p) {
 330         return defaultAction(node, p);
 331     }
 332 
 333     /**
 334      * {@inheritDoc} This implementation calls {@code defaultAction}.
 335      *
 336      * @param node {@inheritDoc}
 337      * @param p {@inheritDoc}
 338      * @return  the result of {@code defaultAction}
 339      */
 340     @Override
 341     public R visitConditionalExpression(ConditionalExpressionTree node, P p) {
 342         return defaultAction(node, p);
 343     }
 344 
 345     /**
 346      * {@inheritDoc} This implementation calls {@code defaultAction}.
 347      *
 348      * @param node {@inheritDoc}
 349      * @param p {@inheritDoc}
 350      * @return  the result of {@code defaultAction}
 351      */
 352     @Override
 353     public R visitIf(IfTree node, P p) {
 354         return defaultAction(node, p);
 355     }
 356 
 357     /**
 358      * {@inheritDoc} This implementation calls {@code defaultAction}.
 359      *
 360      * @param node {@inheritDoc}
 361      * @param p {@inheritDoc}
 362      * @return  the result of {@code defaultAction}
 363      */
 364     @Override
 365     public R visitExpressionStatement(ExpressionStatementTree node, P p) {
 366         return defaultAction(node, p);
 367     }
 368 
 369     /**
 370      * {@inheritDoc} This implementation calls {@code defaultAction}.
 371      *
 372      * @param node {@inheritDoc}
 373      * @param p {@inheritDoc}
 374      * @return  the result of {@code defaultAction}
 375      */
 376     @Override
 377     public R visitBreak(BreakTree node, P p) {
 378         return defaultAction(node, p);
 379     }
 380 
 381     /**
 382      * {@inheritDoc} 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 visitContinue(ContinueTree node, P p) {
 390         return defaultAction(node, p);
 391     }
 392 
 393     /**
 394      * {@inheritDoc} 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 visitReturn(ReturnTree node, P p) {
 402         return defaultAction(node, p);
 403     }
 404 
 405     /**
 406      * {@inheritDoc} This implementation calls {@code defaultAction}.
 407      *
 408      * @param node {@inheritDoc}
 409      * @param p {@inheritDoc}
 410      * @return  the result of {@code defaultAction}
 411      */
 412     @Override
 413     public R visitThrow(ThrowTree node, P p) {
 414         return defaultAction(node, p);
 415     }
 416 
 417     /**
 418      * {@inheritDoc} This implementation calls {@code defaultAction}.
 419      *
 420      * @param node {@inheritDoc}
 421      * @param p {@inheritDoc}
 422      * @return  the result of {@code defaultAction}
 423      */
 424     @Override
 425     public R visitAssert(AssertTree node, P p) {
 426         return defaultAction(node, p);
 427     }
 428 
 429     /**
 430      * {@inheritDoc} This implementation calls {@code defaultAction}.
 431      *
 432      * @param node {@inheritDoc}
 433      * @param p {@inheritDoc}
 434      * @return  the result of {@code defaultAction}
 435      */
 436     @Override
 437     public R visitMethodInvocation(MethodInvocationTree node, P p) {
 438         return defaultAction(node, p);
 439     }
 440 
 441     /**
 442      * {@inheritDoc} This implementation calls {@code defaultAction}.
 443      *
 444      * @param node {@inheritDoc}
 445      * @param p {@inheritDoc}
 446      * @return  the result of {@code defaultAction}
 447      */
 448     @Override
 449     public R visitNewClass(NewClassTree node, P p) {
 450         return defaultAction(node, p);
 451     }
 452 
 453     /**
 454      * {@inheritDoc} This implementation calls {@code defaultAction}.
 455      *
 456      * @param node {@inheritDoc}
 457      * @param p {@inheritDoc}
 458      * @return  the result of {@code defaultAction}
 459      */
 460     @Override
 461     public R visitNewArray(NewArrayTree node, P p) {
 462         return defaultAction(node, p);
 463     }
 464 
 465     /**
 466      * {@inheritDoc} 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 visitLambdaExpression(LambdaExpressionTree node, P p) {
 474         return defaultAction(node, p);
 475     }
 476 
 477     /**
 478      * {@inheritDoc} 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 visitParenthesized(ParenthesizedTree node, P p) {
 486         return defaultAction(node, p);
 487     }
 488 
 489     /**
 490      * {@inheritDoc} This implementation calls {@code defaultAction}.
 491      *
 492      * @param node {@inheritDoc}
 493      * @param p {@inheritDoc}
 494      * @return  the result of {@code defaultAction}
 495      */
 496     @Override
 497     public R visitAssignment(AssignmentTree node, P p) {
 498         return defaultAction(node, p);
 499     }
 500 
 501     /**
 502      * {@inheritDoc} This implementation calls {@code defaultAction}.
 503      *
 504      * @param node {@inheritDoc}
 505      * @param p {@inheritDoc}
 506      * @return  the result of {@code defaultAction}
 507      */
 508     @Override
 509     public R visitCompoundAssignment(CompoundAssignmentTree node, P p) {
 510         return defaultAction(node, p);
 511     }
 512 
 513     /**
 514      * {@inheritDoc} This implementation calls {@code defaultAction}.
 515      *
 516      * @param node {@inheritDoc}
 517      * @param p {@inheritDoc}
 518      * @return  the result of {@code defaultAction}
 519      */
 520     @Override
 521     public R visitUnary(UnaryTree node, P p) {
 522         return defaultAction(node, p);
 523     }
 524 
 525     /**
 526      * {@inheritDoc} This implementation calls {@code defaultAction}.
 527      *
 528      * @param node {@inheritDoc}
 529      * @param p {@inheritDoc}
 530      * @return  the result of {@code defaultAction}
 531      */
 532     @Override
 533     public R visitBinary(BinaryTree node, P p) {
 534         return defaultAction(node, p);
 535     }
 536 
 537     /**
 538      * {@inheritDoc} This implementation calls {@code defaultAction}.
 539      *
 540      * @param node {@inheritDoc}
 541      * @param p {@inheritDoc}
 542      * @return  the result of {@code defaultAction}
 543      */
 544     @Override
 545     public R visitTypeCast(TypeCastTree node, P p) {
 546         return defaultAction(node, p);
 547     }
 548 
 549     /**
 550      * {@inheritDoc} 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 visitInstanceOf(InstanceOfTree node, P p) {
 558         return defaultAction(node, p);
 559     }
 560 
 561     /**
 562      * {@inheritDoc} 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 visitArrayAccess(ArrayAccessTree node, P p) {
 570         return defaultAction(node, p);
 571     }
 572 
 573     /**
 574      * {@inheritDoc} This implementation calls {@code defaultAction}.
 575      *
 576      * @param node {@inheritDoc}
 577      * @param p {@inheritDoc}
 578      * @return  the result of {@code defaultAction}
 579      */
 580     @Override
 581     public R visitMemberSelect(MemberSelectTree node, P p) {
 582         return defaultAction(node, p);
 583     }
 584 
 585     /**
 586      * {@inheritDoc} This implementation calls {@code defaultAction}.
 587      *
 588      * @param node {@inheritDoc}
 589      * @param p {@inheritDoc}
 590      * @return  the result of {@code defaultAction}
 591      */
 592     @Override
 593     public R visitMemberReference(MemberReferenceTree node, P p) {
 594         return defaultAction(node, p);
 595     }
 596 
 597     /**
 598      * {@inheritDoc} This implementation calls {@code defaultAction}.
 599      *
 600      * @param node {@inheritDoc}
 601      * @param p {@inheritDoc}
 602      * @return  the result of {@code defaultAction}
 603      */
 604     @Override
 605     public R visitIdentifier(IdentifierTree node, P p) {
 606         return defaultAction(node, p);
 607     }
 608 
 609     /**
 610      * {@inheritDoc} This implementation calls {@code defaultAction}.
 611      *
 612      * @param node {@inheritDoc}
 613      * @param p {@inheritDoc}
 614      * @return  the result of {@code defaultAction}
 615      */
 616     @Override
 617     public R visitLiteral(LiteralTree node, P p) {
 618         return defaultAction(node, p);
 619     }
 620 
 621     /**
 622      * {@inheritDoc} This implementation calls {@code defaultAction}.
 623      *
 624      * @param node {@inheritDoc}
 625      * @param p {@inheritDoc}
 626      * @return  the result of {@code defaultAction}
 627      */
 628     @Override
 629     public R visitPrimitiveType(PrimitiveTypeTree node, P p) {
 630         return defaultAction(node, p);
 631     }
 632 
 633     /**
 634      * {@inheritDoc} This implementation calls {@code defaultAction}.
 635      *
 636      * @param node {@inheritDoc}
 637      * @param p {@inheritDoc}
 638      * @return  the result of {@code defaultAction}
 639      */
 640     @Override
 641     public R visitArrayType(ArrayTypeTree node, P p) {
 642         return defaultAction(node, p);
 643     }
 644 
 645     /**
 646      * {@inheritDoc} This implementation calls {@code defaultAction}.
 647      *
 648      * @param node {@inheritDoc}
 649      * @param p {@inheritDoc}
 650      * @return  the result of {@code defaultAction}
 651      */
 652     @Override
 653     public R visitParameterizedType(ParameterizedTypeTree node, P p) {
 654         return defaultAction(node, p);
 655     }
 656 
 657     /**
 658      * {@inheritDoc} This implementation calls {@code defaultAction}.
 659      *
 660      * @param node {@inheritDoc}
 661      * @param p {@inheritDoc}
 662      * @return  the result of {@code defaultAction}
 663      */
 664     @Override
 665     public R visitUnionType(UnionTypeTree node, P p) {
 666         return defaultAction(node, p);
 667     }
 668 
 669     /**
 670      * {@inheritDoc} This implementation calls {@code defaultAction}.
 671      *
 672      * @param node {@inheritDoc}
 673      * @param p {@inheritDoc}
 674      * @return  the result of {@code defaultAction}
 675      */
 676     @Override
 677     public R visitIntersectionType(IntersectionTypeTree node, P p) {
 678         return defaultAction(node, p);
 679     }
 680 
 681     /**
 682      * {@inheritDoc} This implementation calls {@code defaultAction}.
 683      *
 684      * @param node {@inheritDoc}
 685      * @param p {@inheritDoc}
 686      * @return  the result of {@code defaultAction}
 687      */
 688     @Override
 689     public R visitTypeParameter(TypeParameterTree node, P p) {
 690         return defaultAction(node, p);
 691     }
 692 
 693     /**
 694      * {@inheritDoc} This implementation calls {@code defaultAction}.
 695      *
 696      * @param node {@inheritDoc}
 697      * @param p {@inheritDoc}
 698      * @return  the result of {@code defaultAction}
 699      */
 700     @Override
 701     public R visitWildcard(WildcardTree node, P p) {
 702         return defaultAction(node, p);
 703     }
 704 
 705     /**
 706      * {@inheritDoc} This implementation calls {@code defaultAction}.
 707      *
 708      * @param node {@inheritDoc}
 709      * @param p {@inheritDoc}
 710      * @return  the result of {@code defaultAction}
 711      */
 712     @Override
 713     public R visitModifiers(ModifiersTree node, P p) {
 714         return defaultAction(node, p);
 715     }
 716 
 717     /**
 718      * {@inheritDoc} This implementation calls {@code defaultAction}.
 719      *
 720      * @param node {@inheritDoc}
 721      * @param p {@inheritDoc}
 722      * @return  the result of {@code defaultAction}
 723      */
 724     @Override
 725     public R visitAnnotation(AnnotationTree node, P p) {
 726         return defaultAction(node, p);
 727     }
 728 
 729     /**
 730      * {@inheritDoc} This implementation calls {@code defaultAction}.
 731      *
 732      * @param node {@inheritDoc}
 733      * @param p {@inheritDoc}
 734      * @return  the result of {@code defaultAction}
 735      */
 736     @Override
 737     public R visitAnnotatedType(AnnotatedTypeTree node, P p) {
 738         return defaultAction(node, p);
 739     }
 740 
 741     public R visitModule(ModuleTree node, P p) {
 742         return defaultAction(node, p);
 743     }
 744 
 745     @Override
 746     public R visitExports(ExportsTree node, P p) {
 747         return defaultAction(node, p);
 748     }
 749 
 750     @Override
 751     public R visitOpens(OpensTree node, P p) {
 752         return defaultAction(node, p);
 753     }
 754 
 755     @Override
 756     public R visitProvides(ProvidesTree node, P p) {
 757         return defaultAction(node, p);
 758     }
 759 
 760     @Override
 761     public R visitRequires(RequiresTree node, P p) {
 762         return defaultAction(node, p);
 763     }
 764 
 765     @Override
 766     public R visitUses(UsesTree node, P p) {
 767         return defaultAction(node, p);
 768     }
 769 
 770     public R visitErroneous(ErroneousTree node, P p) {
 771         return defaultAction(node, p);
 772     }
 773 
 774     /**
 775      * {@inheritDoc} This implementation calls {@code defaultAction}.
 776      *
 777      * @param node {@inheritDoc}
 778      * @param p {@inheritDoc}
 779      * @return  the result of {@code defaultAction}
 780      */
 781     @Override
 782     public R visitOther(Tree node, P p) {
 783         return defaultAction(node, p);
 784     }
 785 
 786     /**
 787      * {@inheritDoc} This implementation calls {@code defaultAction}.
 788      *
 789      * @param node {@inheritDoc}
 790      * @param p {@inheritDoc}
 791      * @return  the result of {@code defaultAction}
 792      */
 793     @Override
 794     @Deprecated(forRemoval=true, since="13")
 795     @SuppressWarnings("removal")
 796     public R visitYield(YieldTree node, P p) {
 797         return defaultAction(node, p);
 798     }
 799 }