1 /******************************************************************************* 2 * Copyright (c) 2000, 2020 IBM Corporation and others. 3 * 4 * This program and the accompanying materials 5 * are made available under the terms of the Eclipse Public License 2.0 6 * which accompanies this distribution, and is available at 7 * https://www.eclipse.org/legal/epl-2.0/ 8 * 9 * SPDX-License-Identifier: EPL-2.0 10 * 11 * Contributors: 12 * IBM Corporation - initial API and implementation 13 *******************************************************************************/ 14 package org.eclipse.jdt.internal.corext.dom; 15 16 import org.eclipse.jdt.core.dom.*; 17 18 /** 19 * ASTVisitor that forwards all <code>visit(*)</code> calls to {@link #visitNode(ASTNode)}. 20 * <p> 21 * Note: New code should better use {@link ASTVisitor#preVisit2(ASTNode)}. 22 * </p> 23 */ 24 // @see JDTUIHelperClasses 25 public class GenericVisitor extends ASTVisitor { 26 GenericVisitor()27 public GenericVisitor() { 28 super(); 29 } 30 31 /** 32 * @param visitJavadocTags <code>true</code> if doc comment tags are 33 * to be visited by default, and <code>false</code> otherwise 34 * @see Javadoc#tags() 35 * @see #visit(Javadoc) 36 * @since 3.0 37 */ GenericVisitor(boolean visitJavadocTags)38 public GenericVisitor(boolean visitJavadocTags) { 39 super(visitJavadocTags); 40 } 41 42 //---- Hooks for subclasses ------------------------------------------------- 43 44 /** 45 * Visits the given type-specific AST node. 46 * 47 * @param node the AST note to visit 48 * @return <code>true</code> if the children of this node should be visited, and 49 * <code>false</code> if the children of this node should be skipped 50 */ visitNode(ASTNode node)51 protected boolean visitNode(ASTNode node) { 52 return true; 53 } 54 55 /** 56 * Visits the given type-specific AST node. 57 * 58 * @param node the AST note to visit 59 */ endVisitNode(ASTNode node)60 protected void endVisitNode(ASTNode node) { 61 // do nothing 62 } 63 64 @Override endVisit(AnnotationTypeDeclaration node)65 public void endVisit(AnnotationTypeDeclaration node) { 66 endVisitNode(node); 67 } 68 @Override endVisit(AnnotationTypeMemberDeclaration node)69 public void endVisit(AnnotationTypeMemberDeclaration node) { 70 endVisitNode(node); 71 } 72 @Override endVisit(AnonymousClassDeclaration node)73 public void endVisit(AnonymousClassDeclaration node) { 74 endVisitNode(node); 75 } 76 @Override endVisit(ArrayAccess node)77 public void endVisit(ArrayAccess node) { 78 endVisitNode(node); 79 } 80 @Override endVisit(ArrayCreation node)81 public void endVisit(ArrayCreation node) { 82 endVisitNode(node); 83 } 84 @Override endVisit(ArrayInitializer node)85 public void endVisit(ArrayInitializer node) { 86 endVisitNode(node); 87 } 88 @Override endVisit(ArrayType node)89 public void endVisit(ArrayType node) { 90 endVisitNode(node); 91 } 92 @Override endVisit(AssertStatement node)93 public void endVisit(AssertStatement node) { 94 endVisitNode(node); 95 } 96 @Override endVisit(Assignment node)97 public void endVisit(Assignment node) { 98 endVisitNode(node); 99 } 100 @Override endVisit(Block node)101 public void endVisit(Block node) { 102 endVisitNode(node); 103 } 104 @Override endVisit(BlockComment node)105 public void endVisit(BlockComment node) { 106 endVisitNode(node); 107 } 108 @Override endVisit(BooleanLiteral node)109 public void endVisit(BooleanLiteral node) { 110 endVisitNode(node); 111 } 112 @Override endVisit(BreakStatement node)113 public void endVisit(BreakStatement node) { 114 endVisitNode(node); 115 } 116 @Override endVisit(CastExpression node)117 public void endVisit(CastExpression node) { 118 endVisitNode(node); 119 } 120 @Override endVisit(CatchClause node)121 public void endVisit(CatchClause node) { 122 endVisitNode(node); 123 } 124 @Override endVisit(CharacterLiteral node)125 public void endVisit(CharacterLiteral node) { 126 endVisitNode(node); 127 } 128 @Override endVisit(ClassInstanceCreation node)129 public void endVisit(ClassInstanceCreation node) { 130 endVisitNode(node); 131 } 132 @Override endVisit(CompilationUnit node)133 public void endVisit(CompilationUnit node) { 134 endVisitNode(node); 135 } 136 @Override endVisit(ConditionalExpression node)137 public void endVisit(ConditionalExpression node) { 138 endVisitNode(node); 139 } 140 @Override endVisit(ConstructorInvocation node)141 public void endVisit(ConstructorInvocation node) { 142 endVisitNode(node); 143 } 144 @Override endVisit(ContinueStatement node)145 public void endVisit(ContinueStatement node) { 146 endVisitNode(node); 147 } 148 @Override endVisit(CreationReference node)149 public void endVisit(CreationReference node) { 150 endVisitNode(node); 151 } 152 @Override endVisit(Dimension node)153 public void endVisit(Dimension node) { 154 endVisitNode(node); 155 } 156 @Override endVisit(DoStatement node)157 public void endVisit(DoStatement node) { 158 endVisitNode(node); 159 } 160 @Override endVisit(EmptyStatement node)161 public void endVisit(EmptyStatement node) { 162 endVisitNode(node); 163 } 164 @Override endVisit(EnhancedForStatement node)165 public void endVisit(EnhancedForStatement node) { 166 endVisitNode(node); 167 } 168 @Override endVisit(EnumConstantDeclaration node)169 public void endVisit(EnumConstantDeclaration node) { 170 endVisitNode(node); 171 } 172 @Override endVisit(EnumDeclaration node)173 public void endVisit(EnumDeclaration node) { 174 endVisitNode(node); 175 } 176 @Override endVisit(ExportsDirective node)177 public void endVisit(ExportsDirective node) { 178 endVisitNode(node); 179 } 180 @Override endVisit(ExpressionMethodReference node)181 public void endVisit(ExpressionMethodReference node) { 182 endVisitNode(node); 183 } 184 @Override endVisit(ExpressionStatement node)185 public void endVisit(ExpressionStatement node) { 186 endVisitNode(node); 187 } 188 @Override endVisit(FieldAccess node)189 public void endVisit(FieldAccess node) { 190 endVisitNode(node); 191 } 192 @Override endVisit(FieldDeclaration node)193 public void endVisit(FieldDeclaration node) { 194 endVisitNode(node); 195 } 196 @Override endVisit(ForStatement node)197 public void endVisit(ForStatement node) { 198 endVisitNode(node); 199 } 200 @Override endVisit(IfStatement node)201 public void endVisit(IfStatement node) { 202 endVisitNode(node); 203 } 204 @Override endVisit(ImportDeclaration node)205 public void endVisit(ImportDeclaration node) { 206 endVisitNode(node); 207 } 208 @Override endVisit(InfixExpression node)209 public void endVisit(InfixExpression node) { 210 endVisitNode(node); 211 } 212 @Override endVisit(Initializer node)213 public void endVisit(Initializer node) { 214 endVisitNode(node); 215 } 216 @Override endVisit(InstanceofExpression node)217 public void endVisit(InstanceofExpression node) { 218 endVisitNode(node); 219 } 220 @Override endVisit(IntersectionType node)221 public void endVisit(IntersectionType node) { 222 endVisitNode(node); 223 } 224 @Override endVisit(Javadoc node)225 public void endVisit(Javadoc node) { 226 endVisitNode(node); 227 } 228 @Override endVisit(LabeledStatement node)229 public void endVisit(LabeledStatement node) { 230 endVisitNode(node); 231 } 232 @Override endVisit(LambdaExpression node)233 public void endVisit(LambdaExpression node) { 234 endVisitNode(node); 235 } 236 @Override endVisit(LineComment node)237 public void endVisit(LineComment node) { 238 endVisitNode(node); 239 } 240 @Override endVisit(MarkerAnnotation node)241 public void endVisit(MarkerAnnotation node) { 242 endVisitNode(node); 243 } 244 @Override endVisit(MemberRef node)245 public void endVisit(MemberRef node) { 246 endVisitNode(node); 247 } 248 @Override endVisit(MemberValuePair node)249 public void endVisit(MemberValuePair node) { 250 endVisitNode(node); 251 } 252 @Override endVisit(MethodDeclaration node)253 public void endVisit(MethodDeclaration node) { 254 endVisitNode(node); 255 } 256 @Override endVisit(MethodInvocation node)257 public void endVisit(MethodInvocation node) { 258 endVisitNode(node); 259 } 260 @Override endVisit(MethodRef node)261 public void endVisit(MethodRef node) { 262 endVisitNode(node); 263 } 264 @Override endVisit(MethodRefParameter node)265 public void endVisit(MethodRefParameter node) { 266 endVisitNode(node); 267 } 268 @Override endVisit(Modifier node)269 public void endVisit(Modifier node) { 270 endVisitNode(node); 271 } 272 @Override endVisit(ModuleDeclaration node)273 public void endVisit(ModuleDeclaration node) { 274 endVisitNode(node); 275 } 276 @Override endVisit(ModuleModifier node)277 public void endVisit(ModuleModifier node) { 278 endVisitNode(node); 279 } 280 @Override endVisit(NameQualifiedType node)281 public void endVisit(NameQualifiedType node) { 282 endVisitNode(node); 283 } 284 @Override endVisit(NormalAnnotation node)285 public void endVisit(NormalAnnotation node) { 286 endVisitNode(node); 287 } 288 @Override endVisit(NullLiteral node)289 public void endVisit(NullLiteral node) { 290 endVisitNode(node); 291 } 292 @Override endVisit(NumberLiteral node)293 public void endVisit(NumberLiteral node) { 294 endVisitNode(node); 295 } 296 @Override endVisit(OpensDirective node)297 public void endVisit(OpensDirective node) { 298 endVisitNode(node); 299 } 300 @Override endVisit(PackageDeclaration node)301 public void endVisit(PackageDeclaration node) { 302 endVisitNode(node); 303 } 304 @Override endVisit(ParameterizedType node)305 public void endVisit(ParameterizedType node) { 306 endVisitNode(node); 307 } 308 @Override endVisit(ParenthesizedExpression node)309 public void endVisit(ParenthesizedExpression node) { 310 endVisitNode(node); 311 } 312 @Override endVisit(PostfixExpression node)313 public void endVisit(PostfixExpression node) { 314 endVisitNode(node); 315 } 316 @Override endVisit(PrefixExpression node)317 public void endVisit(PrefixExpression node) { 318 endVisitNode(node); 319 } 320 @Override endVisit(PrimitiveType node)321 public void endVisit(PrimitiveType node) { 322 endVisitNode(node); 323 } 324 @Override endVisit(ProvidesDirective node)325 public void endVisit(ProvidesDirective node) { 326 endVisitNode(node); 327 } 328 @Override endVisit(QualifiedName node)329 public void endVisit(QualifiedName node) { 330 endVisitNode(node); 331 } 332 @Override endVisit(QualifiedType node)333 public void endVisit(QualifiedType node) { 334 endVisitNode(node); 335 } 336 @Override endVisit(RecordDeclaration node)337 public void endVisit(RecordDeclaration node) { 338 endVisitNode(node); 339 } 340 @Override endVisit(RequiresDirective node)341 public void endVisit(RequiresDirective node) { 342 endVisitNode(node); 343 } 344 @Override endVisit(ReturnStatement node)345 public void endVisit(ReturnStatement node) { 346 endVisitNode(node); 347 } 348 @Override endVisit(SimpleName node)349 public void endVisit(SimpleName node) { 350 endVisitNode(node); 351 } 352 @Override endVisit(SimpleType node)353 public void endVisit(SimpleType node) { 354 endVisitNode(node); 355 } 356 @Override endVisit(SingleMemberAnnotation node)357 public void endVisit(SingleMemberAnnotation node) { 358 endVisitNode(node); 359 } 360 @Override endVisit(SingleVariableDeclaration node)361 public void endVisit(SingleVariableDeclaration node) { 362 endVisitNode(node); 363 } 364 @Override endVisit(StringLiteral node)365 public void endVisit(StringLiteral node) { 366 endVisitNode(node); 367 } 368 @Override endVisit(SuperConstructorInvocation node)369 public void endVisit(SuperConstructorInvocation node) { 370 endVisitNode(node); 371 } 372 @Override endVisit(SuperFieldAccess node)373 public void endVisit(SuperFieldAccess node) { 374 endVisitNode(node); 375 } 376 @Override endVisit(SuperMethodInvocation node)377 public void endVisit(SuperMethodInvocation node) { 378 endVisitNode(node); 379 } 380 @Override endVisit(SuperMethodReference node)381 public void endVisit(SuperMethodReference node) { 382 endVisitNode(node); 383 } 384 @Override endVisit(SwitchCase node)385 public void endVisit(SwitchCase node) { 386 endVisitNode(node); 387 } 388 @Override endVisit(SwitchExpression node)389 public void endVisit(SwitchExpression node) { 390 endVisitNode(node); 391 } 392 @Override endVisit(SwitchStatement node)393 public void endVisit(SwitchStatement node) { 394 endVisitNode(node); 395 } 396 @Override endVisit(SynchronizedStatement node)397 public void endVisit(SynchronizedStatement node) { 398 endVisitNode(node); 399 } 400 @Override endVisit(TagElement node)401 public void endVisit(TagElement node) { 402 endVisitNode(node); 403 } 404 @Override endVisit(TextElement node)405 public void endVisit(TextElement node) { 406 endVisitNode(node); 407 } 408 @Override endVisit(ThisExpression node)409 public void endVisit(ThisExpression node) { 410 endVisitNode(node); 411 } 412 @Override endVisit(ThrowStatement node)413 public void endVisit(ThrowStatement node) { 414 endVisitNode(node); 415 } 416 @Override endVisit(TryStatement node)417 public void endVisit(TryStatement node) { 418 endVisitNode(node); 419 } 420 @Override endVisit(TypeDeclaration node)421 public void endVisit(TypeDeclaration node) { 422 endVisitNode(node); 423 } 424 @Override endVisit(TypeDeclarationStatement node)425 public void endVisit(TypeDeclarationStatement node) { 426 endVisitNode(node); 427 } 428 @Override endVisit(TypeLiteral node)429 public void endVisit(TypeLiteral node) { 430 endVisitNode(node); 431 } 432 @Override endVisit(TypeMethodReference node)433 public void endVisit(TypeMethodReference node) { 434 endVisitNode(node); 435 } 436 @Override endVisit(TypeParameter node)437 public void endVisit(TypeParameter node) { 438 endVisitNode(node); 439 } 440 @Override endVisit(TextBlock node)441 public void endVisit(TextBlock node) { 442 endVisitNode(node); 443 } 444 @Override endVisit(UnionType node)445 public void endVisit(UnionType node) { 446 endVisitNode(node); 447 } 448 @Override endVisit(UsesDirective node)449 public void endVisit(UsesDirective node) { 450 endVisitNode(node); 451 } 452 @Override endVisit(VariableDeclarationExpression node)453 public void endVisit(VariableDeclarationExpression node) { 454 endVisitNode(node); 455 } 456 @Override endVisit(VariableDeclarationFragment node)457 public void endVisit(VariableDeclarationFragment node) { 458 endVisitNode(node); 459 } 460 @Override endVisit(VariableDeclarationStatement node)461 public void endVisit(VariableDeclarationStatement node) { 462 endVisitNode(node); 463 } 464 @Override endVisit(WhileStatement node)465 public void endVisit(WhileStatement node) { 466 endVisitNode(node); 467 } 468 @Override endVisit(WildcardType node)469 public void endVisit(WildcardType node) { 470 endVisitNode(node); 471 } 472 473 @Override endVisit(YieldStatement node)474 public void endVisit(YieldStatement node) { 475 endVisitNode(node); 476 } 477 478 @Override visit(AnnotationTypeDeclaration node)479 public boolean visit(AnnotationTypeDeclaration node) { 480 return visitNode(node); 481 } 482 @Override visit(AnnotationTypeMemberDeclaration node)483 public boolean visit(AnnotationTypeMemberDeclaration node) { 484 return visitNode(node); 485 } 486 @Override visit(AnonymousClassDeclaration node)487 public boolean visit(AnonymousClassDeclaration node) { 488 return visitNode(node); 489 } 490 @Override visit(ArrayAccess node)491 public boolean visit(ArrayAccess node) { 492 return visitNode(node); 493 } 494 @Override visit(ArrayCreation node)495 public boolean visit(ArrayCreation node) { 496 return visitNode(node); 497 } 498 @Override visit(ArrayInitializer node)499 public boolean visit(ArrayInitializer node) { 500 return visitNode(node); 501 } 502 @Override visit(ArrayType node)503 public boolean visit(ArrayType node) { 504 return visitNode(node); 505 } 506 @Override visit(AssertStatement node)507 public boolean visit(AssertStatement node) { 508 return visitNode(node); 509 } 510 @Override visit(Assignment node)511 public boolean visit(Assignment node) { 512 return visitNode(node); 513 } 514 @Override visit(Block node)515 public boolean visit(Block node) { 516 return visitNode(node); 517 } 518 @Override visit(BlockComment node)519 public boolean visit(BlockComment node) { 520 return visitNode(node); 521 } 522 @Override visit(BooleanLiteral node)523 public boolean visit(BooleanLiteral node) { 524 return visitNode(node); 525 } 526 @Override visit(BreakStatement node)527 public boolean visit(BreakStatement node) { 528 return visitNode(node); 529 } 530 @Override visit(CastExpression node)531 public boolean visit(CastExpression node) { 532 return visitNode(node); 533 } 534 @Override visit(CatchClause node)535 public boolean visit(CatchClause node) { 536 return visitNode(node); 537 } 538 @Override visit(CharacterLiteral node)539 public boolean visit(CharacterLiteral node) { 540 return visitNode(node); 541 } 542 @Override visit(ClassInstanceCreation node)543 public boolean visit(ClassInstanceCreation node) { 544 return visitNode(node); 545 } 546 @Override visit(CompilationUnit node)547 public boolean visit(CompilationUnit node) { 548 return visitNode(node); 549 } 550 @Override visit(ConditionalExpression node)551 public boolean visit(ConditionalExpression node) { 552 return visitNode(node); 553 } 554 @Override visit(ConstructorInvocation node)555 public boolean visit(ConstructorInvocation node) { 556 return visitNode(node); 557 } 558 @Override visit(ContinueStatement node)559 public boolean visit(ContinueStatement node) { 560 return visitNode(node); 561 } 562 @Override visit(CreationReference node)563 public boolean visit(CreationReference node) { 564 return visitNode(node); 565 } 566 @Override visit(Dimension node)567 public boolean visit(Dimension node) { 568 return visitNode(node); 569 } 570 @Override visit(DoStatement node)571 public boolean visit(DoStatement node) { 572 return visitNode(node); 573 } 574 @Override visit(EmptyStatement node)575 public boolean visit(EmptyStatement node) { 576 return visitNode(node); 577 } 578 @Override visit(EnhancedForStatement node)579 public boolean visit(EnhancedForStatement node) { 580 return visitNode(node); 581 } 582 @Override visit(EnumConstantDeclaration node)583 public boolean visit(EnumConstantDeclaration node) { 584 return visitNode(node); 585 } 586 @Override visit(EnumDeclaration node)587 public boolean visit(EnumDeclaration node) { 588 return visitNode(node); 589 } 590 @Override visit(ExportsDirective node)591 public boolean visit(ExportsDirective node) { 592 return visitNode(node); 593 } 594 @Override visit(ExpressionMethodReference node)595 public boolean visit(ExpressionMethodReference node) { 596 return visitNode(node); 597 } 598 @Override visit(ExpressionStatement node)599 public boolean visit(ExpressionStatement node) { 600 return visitNode(node); 601 } 602 @Override visit(FieldAccess node)603 public boolean visit(FieldAccess node) { 604 return visitNode(node); 605 } 606 @Override visit(FieldDeclaration node)607 public boolean visit(FieldDeclaration node) { 608 return visitNode(node); 609 } 610 @Override visit(ForStatement node)611 public boolean visit(ForStatement node) { 612 return visitNode(node); 613 } 614 @Override visit(IfStatement node)615 public boolean visit(IfStatement node) { 616 return visitNode(node); 617 } 618 @Override visit(ImportDeclaration node)619 public boolean visit(ImportDeclaration node) { 620 return visitNode(node); 621 } 622 @Override visit(InfixExpression node)623 public boolean visit(InfixExpression node) { 624 return visitNode(node); 625 } 626 @Override visit(Initializer node)627 public boolean visit(Initializer node) { 628 return visitNode(node); 629 } 630 @Override visit(InstanceofExpression node)631 public boolean visit(InstanceofExpression node) { 632 return visitNode(node); 633 } 634 @Override visit(IntersectionType node)635 public boolean visit(IntersectionType node) { 636 return visitNode(node); 637 } 638 @Override visit(Javadoc node)639 public boolean visit(Javadoc node) { 640 if (super.visit(node)) 641 return visitNode(node); 642 else 643 return false; 644 } 645 @Override visit(LabeledStatement node)646 public boolean visit(LabeledStatement node) { 647 return visitNode(node); 648 } 649 @Override visit(LambdaExpression node)650 public boolean visit(LambdaExpression node) { 651 return visitNode(node); 652 } 653 @Override visit(LineComment node)654 public boolean visit(LineComment node) { 655 return visitNode(node); 656 } 657 @Override visit(MarkerAnnotation node)658 public boolean visit(MarkerAnnotation node) { 659 return visitNode(node); 660 } 661 @Override visit(MemberRef node)662 public boolean visit(MemberRef node) { 663 return visitNode(node); 664 } 665 @Override visit(MemberValuePair node)666 public boolean visit(MemberValuePair node) { 667 return visitNode(node); 668 } 669 @Override visit(MethodDeclaration node)670 public boolean visit(MethodDeclaration node) { 671 return visitNode(node); 672 } 673 @Override visit(MethodInvocation node)674 public boolean visit(MethodInvocation node) { 675 return visitNode(node); 676 } 677 @Override visit(MethodRef node)678 public boolean visit(MethodRef node) { 679 return visitNode(node); 680 } 681 @Override visit(MethodRefParameter node)682 public boolean visit(MethodRefParameter node) { 683 return visitNode(node); 684 } 685 @Override visit(Modifier node)686 public boolean visit(Modifier node) { 687 return visitNode(node); 688 } 689 @Override visit(ModuleDeclaration node)690 public boolean visit(ModuleDeclaration node) { 691 return visitNode(node); 692 } 693 @Override visit(ModuleModifier node)694 public boolean visit(ModuleModifier node) { 695 return visitNode(node); 696 } 697 @Override visit(NameQualifiedType node)698 public boolean visit(NameQualifiedType node) { 699 return visitNode(node); 700 } 701 @Override visit(NormalAnnotation node)702 public boolean visit(NormalAnnotation node) { 703 return visitNode(node); 704 } 705 @Override visit(NullLiteral node)706 public boolean visit(NullLiteral node) { 707 return visitNode(node); 708 } 709 @Override visit(NumberLiteral node)710 public boolean visit(NumberLiteral node) { 711 return visitNode(node); 712 } 713 @Override visit(OpensDirective node)714 public boolean visit(OpensDirective node) { 715 return visitNode(node); 716 } 717 @Override visit(PackageDeclaration node)718 public boolean visit(PackageDeclaration node) { 719 return visitNode(node); 720 } 721 @Override visit(ParameterizedType node)722 public boolean visit(ParameterizedType node) { 723 return visitNode(node); 724 } 725 @Override visit(ParenthesizedExpression node)726 public boolean visit(ParenthesizedExpression node) { 727 return visitNode(node); 728 } 729 @Override visit(PostfixExpression node)730 public boolean visit(PostfixExpression node) { 731 return visitNode(node); 732 } 733 @Override visit(PrefixExpression node)734 public boolean visit(PrefixExpression node) { 735 return visitNode(node); 736 } 737 @Override visit(PrimitiveType node)738 public boolean visit(PrimitiveType node) { 739 return visitNode(node); 740 } 741 @Override visit(ProvidesDirective node)742 public boolean visit(ProvidesDirective node) { 743 return visitNode(node); 744 } 745 @Override visit(QualifiedName node)746 public boolean visit(QualifiedName node) { 747 return visitNode(node); 748 } 749 @Override visit(QualifiedType node)750 public boolean visit(QualifiedType node) { 751 return visitNode(node); 752 } 753 @Override visit(RecordDeclaration node)754 public boolean visit(RecordDeclaration node) { 755 return visitNode(node); 756 } 757 @Override visit(RequiresDirective node)758 public boolean visit(RequiresDirective node) { 759 return visitNode(node); 760 } 761 @Override visit(ReturnStatement node)762 public boolean visit(ReturnStatement node) { 763 return visitNode(node); 764 } 765 @Override visit(SimpleName node)766 public boolean visit(SimpleName node) { 767 return visitNode(node); 768 } 769 @Override visit(SimpleType node)770 public boolean visit(SimpleType node) { 771 return visitNode(node); 772 } 773 @Override visit(SingleMemberAnnotation node)774 public boolean visit(SingleMemberAnnotation node) { 775 return visitNode(node); 776 } 777 @Override visit(SingleVariableDeclaration node)778 public boolean visit(SingleVariableDeclaration node) { 779 return visitNode(node); 780 } 781 @Override visit(StringLiteral node)782 public boolean visit(StringLiteral node) { 783 return visitNode(node); 784 } 785 @Override visit(SuperConstructorInvocation node)786 public boolean visit(SuperConstructorInvocation node) { 787 return visitNode(node); 788 } 789 @Override visit(SuperFieldAccess node)790 public boolean visit(SuperFieldAccess node) { 791 return visitNode(node); 792 } 793 @Override visit(SuperMethodInvocation node)794 public boolean visit(SuperMethodInvocation node) { 795 return visitNode(node); 796 } 797 @Override visit(SuperMethodReference node)798 public boolean visit(SuperMethodReference node) { 799 return visitNode(node); 800 } 801 @Override visit(SwitchCase node)802 public boolean visit(SwitchCase node) { 803 return visitNode(node); 804 } 805 @Override visit(SwitchExpression node)806 public boolean visit(SwitchExpression node) { 807 return visitNode(node); 808 } 809 @Override visit(SwitchStatement node)810 public boolean visit(SwitchStatement node) { 811 return visitNode(node); 812 } 813 @Override visit(SynchronizedStatement node)814 public boolean visit(SynchronizedStatement node) { 815 return visitNode(node); 816 } 817 @Override visit(TagElement node)818 public boolean visit(TagElement node) { 819 return visitNode(node); 820 } 821 @Override visit(TextElement node)822 public boolean visit(TextElement node) { 823 return visitNode(node); 824 } 825 @Override visit(ThisExpression node)826 public boolean visit(ThisExpression node) { 827 return visitNode(node); 828 } 829 @Override visit(ThrowStatement node)830 public boolean visit(ThrowStatement node) { 831 return visitNode(node); 832 } 833 @Override visit(TryStatement node)834 public boolean visit(TryStatement node) { 835 return visitNode(node); 836 } 837 @Override visit(TypeDeclaration node)838 public boolean visit(TypeDeclaration node) { 839 return visitNode(node); 840 } 841 @Override visit(TypeDeclarationStatement node)842 public boolean visit(TypeDeclarationStatement node) { 843 return visitNode(node); 844 } 845 @Override visit(TypeLiteral node)846 public boolean visit(TypeLiteral node) { 847 return visitNode(node); 848 } 849 @Override visit(TypeMethodReference node)850 public boolean visit(TypeMethodReference node) { 851 return visitNode(node); 852 } 853 @Override visit(TypeParameter node)854 public boolean visit(TypeParameter node) { 855 return visitNode(node); 856 } 857 @Override visit(TextBlock node)858 public boolean visit(TextBlock node) { 859 return visitNode(node); 860 } 861 @Override visit(UnionType node)862 public boolean visit(UnionType node) { 863 return visitNode(node); 864 } 865 @Override visit(UsesDirective node)866 public boolean visit(UsesDirective node) { 867 return visitNode(node); 868 } 869 @Override visit(VariableDeclarationExpression node)870 public boolean visit(VariableDeclarationExpression node) { 871 return visitNode(node); 872 } 873 @Override visit(VariableDeclarationFragment node)874 public boolean visit(VariableDeclarationFragment node) { 875 return visitNode(node); 876 } 877 @Override visit(VariableDeclarationStatement node)878 public boolean visit(VariableDeclarationStatement node) { 879 return visitNode(node); 880 } 881 @Override visit(WhileStatement node)882 public boolean visit(WhileStatement node) { 883 return visitNode(node); 884 } 885 @Override visit(WildcardType node)886 public boolean visit(WildcardType node) { 887 return visitNode(node); 888 } 889 @Override visit(YieldStatement node)890 public boolean visit(YieldStatement node) { 891 return visitNode(node); 892 } 893 } 894