1 /******************************************************************************* 2 * Copyright (c) 2000, 2011 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.refactoring.code; 15 16 import java.util.ArrayList; 17 import java.util.Collection; 18 19 import org.eclipse.jdt.core.dom.ASTMatcher; 20 import org.eclipse.jdt.core.dom.ASTNode; 21 import org.eclipse.jdt.core.dom.ASTVisitor; 22 import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration; 23 import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration; 24 import org.eclipse.jdt.core.dom.AnonymousClassDeclaration; 25 import org.eclipse.jdt.core.dom.ArrayAccess; 26 import org.eclipse.jdt.core.dom.ArrayCreation; 27 import org.eclipse.jdt.core.dom.ArrayInitializer; 28 import org.eclipse.jdt.core.dom.ArrayType; 29 import org.eclipse.jdt.core.dom.AssertStatement; 30 import org.eclipse.jdt.core.dom.Assignment; 31 import org.eclipse.jdt.core.dom.Block; 32 import org.eclipse.jdt.core.dom.BlockComment; 33 import org.eclipse.jdt.core.dom.BooleanLiteral; 34 import org.eclipse.jdt.core.dom.BreakStatement; 35 import org.eclipse.jdt.core.dom.CastExpression; 36 import org.eclipse.jdt.core.dom.CatchClause; 37 import org.eclipse.jdt.core.dom.CharacterLiteral; 38 import org.eclipse.jdt.core.dom.ClassInstanceCreation; 39 import org.eclipse.jdt.core.dom.CompilationUnit; 40 import org.eclipse.jdt.core.dom.ConditionalExpression; 41 import org.eclipse.jdt.core.dom.ConstructorInvocation; 42 import org.eclipse.jdt.core.dom.ContinueStatement; 43 import org.eclipse.jdt.core.dom.DoStatement; 44 import org.eclipse.jdt.core.dom.EmptyStatement; 45 import org.eclipse.jdt.core.dom.EnhancedForStatement; 46 import org.eclipse.jdt.core.dom.EnumConstantDeclaration; 47 import org.eclipse.jdt.core.dom.EnumDeclaration; 48 import org.eclipse.jdt.core.dom.ExpressionStatement; 49 import org.eclipse.jdt.core.dom.FieldAccess; 50 import org.eclipse.jdt.core.dom.FieldDeclaration; 51 import org.eclipse.jdt.core.dom.ForStatement; 52 import org.eclipse.jdt.core.dom.IfStatement; 53 import org.eclipse.jdt.core.dom.ImportDeclaration; 54 import org.eclipse.jdt.core.dom.InfixExpression; 55 import org.eclipse.jdt.core.dom.Initializer; 56 import org.eclipse.jdt.core.dom.InstanceofExpression; 57 import org.eclipse.jdt.core.dom.Javadoc; 58 import org.eclipse.jdt.core.dom.LabeledStatement; 59 import org.eclipse.jdt.core.dom.LineComment; 60 import org.eclipse.jdt.core.dom.MarkerAnnotation; 61 import org.eclipse.jdt.core.dom.MemberRef; 62 import org.eclipse.jdt.core.dom.MemberValuePair; 63 import org.eclipse.jdt.core.dom.MethodDeclaration; 64 import org.eclipse.jdt.core.dom.MethodInvocation; 65 import org.eclipse.jdt.core.dom.MethodRef; 66 import org.eclipse.jdt.core.dom.MethodRefParameter; 67 import org.eclipse.jdt.core.dom.Modifier; 68 import org.eclipse.jdt.core.dom.NormalAnnotation; 69 import org.eclipse.jdt.core.dom.NullLiteral; 70 import org.eclipse.jdt.core.dom.NumberLiteral; 71 import org.eclipse.jdt.core.dom.PackageDeclaration; 72 import org.eclipse.jdt.core.dom.ParameterizedType; 73 import org.eclipse.jdt.core.dom.ParenthesizedExpression; 74 import org.eclipse.jdt.core.dom.PostfixExpression; 75 import org.eclipse.jdt.core.dom.PrefixExpression; 76 import org.eclipse.jdt.core.dom.PrimitiveType; 77 import org.eclipse.jdt.core.dom.QualifiedName; 78 import org.eclipse.jdt.core.dom.QualifiedType; 79 import org.eclipse.jdt.core.dom.ReturnStatement; 80 import org.eclipse.jdt.core.dom.SimpleName; 81 import org.eclipse.jdt.core.dom.SimpleType; 82 import org.eclipse.jdt.core.dom.SingleMemberAnnotation; 83 import org.eclipse.jdt.core.dom.SingleVariableDeclaration; 84 import org.eclipse.jdt.core.dom.StringLiteral; 85 import org.eclipse.jdt.core.dom.SuperConstructorInvocation; 86 import org.eclipse.jdt.core.dom.SuperFieldAccess; 87 import org.eclipse.jdt.core.dom.SuperMethodInvocation; 88 import org.eclipse.jdt.core.dom.SwitchCase; 89 import org.eclipse.jdt.core.dom.SwitchStatement; 90 import org.eclipse.jdt.core.dom.SynchronizedStatement; 91 import org.eclipse.jdt.core.dom.TagElement; 92 import org.eclipse.jdt.core.dom.TextElement; 93 import org.eclipse.jdt.core.dom.ThisExpression; 94 import org.eclipse.jdt.core.dom.ThrowStatement; 95 import org.eclipse.jdt.core.dom.TryStatement; 96 import org.eclipse.jdt.core.dom.TypeDeclaration; 97 import org.eclipse.jdt.core.dom.TypeDeclarationStatement; 98 import org.eclipse.jdt.core.dom.TypeLiteral; 99 import org.eclipse.jdt.core.dom.TypeParameter; 100 import org.eclipse.jdt.core.dom.VariableDeclarationExpression; 101 import org.eclipse.jdt.core.dom.VariableDeclarationFragment; 102 import org.eclipse.jdt.core.dom.VariableDeclarationStatement; 103 import org.eclipse.jdt.core.dom.WhileStatement; 104 import org.eclipse.jdt.core.dom.WildcardType; 105 106 import org.eclipse.jdt.internal.corext.dom.JdtASTMatcher; 107 108 class AstMatchingNodeFinder { 109 AstMatchingNodeFinder()110 private AstMatchingNodeFinder(){ 111 } 112 findMatchingNodes(ASTNode scope, ASTNode node)113 public static ASTNode[] findMatchingNodes(ASTNode scope, ASTNode node){ 114 Visitor visitor= new Visitor(node); 115 scope.accept(visitor); 116 return visitor.getMatchingNodes(); 117 } 118 119 private static class Visitor extends ASTVisitor{ 120 121 Collection<ASTNode> fFound; 122 ASTMatcher fMatcher; 123 ASTNode fNodeToMatch; 124 Visitor(ASTNode nodeToMatch)125 Visitor(ASTNode nodeToMatch){ 126 fNodeToMatch= nodeToMatch; 127 fFound= new ArrayList<>(); 128 fMatcher= new JdtASTMatcher(); 129 } 130 getMatchingNodes()131 ASTNode[] getMatchingNodes(){ 132 return fFound.toArray(new ASTNode[fFound.size()]); 133 } 134 matches(ASTNode node)135 private boolean matches(ASTNode node){ 136 fFound.add(node); 137 return false; 138 } 139 140 @Override visit(AnonymousClassDeclaration node)141 public boolean visit(AnonymousClassDeclaration node) { 142 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 143 return matches(node); 144 return super.visit(node); 145 } 146 147 @Override visit(ArrayAccess node)148 public boolean visit(ArrayAccess node) { 149 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 150 return matches(node); 151 return super.visit(node); 152 } 153 154 @Override visit(ArrayCreation node)155 public boolean visit(ArrayCreation node) { 156 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 157 return matches(node); 158 return super.visit(node); 159 } 160 161 @Override visit(ArrayInitializer node)162 public boolean visit(ArrayInitializer node) { 163 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 164 return matches(node); 165 return super.visit(node); 166 } 167 168 @Override visit(ArrayType node)169 public boolean visit(ArrayType node) { 170 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 171 return matches(node); 172 return super.visit(node); 173 } 174 175 @Override visit(AssertStatement node)176 public boolean visit(AssertStatement node) { 177 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 178 return matches(node); 179 return super.visit(node); 180 } 181 182 @Override visit(Assignment node)183 public boolean visit(Assignment node) { 184 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 185 return matches(node); 186 return super.visit(node); 187 } 188 189 @Override visit(Block node)190 public boolean visit(Block node) { 191 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 192 return matches(node); 193 return super.visit(node); 194 } 195 196 @Override visit(BooleanLiteral node)197 public boolean visit(BooleanLiteral node) { 198 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 199 return matches(node); 200 return super.visit(node); 201 } 202 203 @Override visit(BreakStatement node)204 public boolean visit(BreakStatement node) { 205 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 206 return matches(node); 207 return super.visit(node); 208 } 209 210 @Override visit(CastExpression node)211 public boolean visit(CastExpression node) { 212 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 213 return matches(node); 214 return super.visit(node); 215 } 216 217 @Override visit(CatchClause node)218 public boolean visit(CatchClause node) { 219 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 220 return matches(node); 221 return super.visit(node); 222 } 223 224 @Override visit(CharacterLiteral node)225 public boolean visit(CharacterLiteral node) { 226 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 227 return matches(node); 228 return super.visit(node); 229 } 230 231 @Override visit(ClassInstanceCreation node)232 public boolean visit(ClassInstanceCreation node) { 233 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 234 return matches(node); 235 return super.visit(node); 236 } 237 238 @Override visit(CompilationUnit node)239 public boolean visit(CompilationUnit node) { 240 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 241 return matches(node); 242 return super.visit(node); 243 } 244 245 @Override visit(ConditionalExpression node)246 public boolean visit(ConditionalExpression node) { 247 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 248 return matches(node); 249 return super.visit(node); 250 } 251 252 @Override visit(ConstructorInvocation node)253 public boolean visit(ConstructorInvocation node) { 254 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 255 return matches(node); 256 return super.visit(node); 257 } 258 259 @Override visit(ContinueStatement node)260 public boolean visit(ContinueStatement node) { 261 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 262 return matches(node); 263 return super.visit(node); 264 } 265 266 @Override visit(DoStatement node)267 public boolean visit(DoStatement node) { 268 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 269 return matches(node); 270 return super.visit(node); 271 } 272 273 @Override visit(EmptyStatement node)274 public boolean visit(EmptyStatement node) { 275 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 276 return matches(node); 277 return super.visit(node); 278 } 279 280 @Override visit(ExpressionStatement node)281 public boolean visit(ExpressionStatement node) { 282 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 283 return matches(node); 284 return super.visit(node); 285 } 286 287 @Override visit(FieldAccess node)288 public boolean visit(FieldAccess node) { 289 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 290 return matches(node); 291 return super.visit(node); 292 } 293 294 @Override visit(FieldDeclaration node)295 public boolean visit(FieldDeclaration node) { 296 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 297 return matches(node); 298 return super.visit(node); 299 } 300 301 @Override visit(ForStatement node)302 public boolean visit(ForStatement node) { 303 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 304 return matches(node); 305 return super.visit(node); 306 } 307 308 @Override visit(IfStatement node)309 public boolean visit(IfStatement node) { 310 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 311 return matches(node); 312 return super.visit(node); 313 } 314 315 @Override visit(ImportDeclaration node)316 public boolean visit(ImportDeclaration node) { 317 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 318 return matches(node); 319 return super.visit(node); 320 } 321 322 @Override visit(InfixExpression node)323 public boolean visit(InfixExpression node) { 324 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 325 return matches(node); 326 return super.visit(node); 327 } 328 329 @Override visit(Initializer node)330 public boolean visit(Initializer node) { 331 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 332 return matches(node); 333 return super.visit(node); 334 } 335 336 @Override visit(InstanceofExpression node)337 public boolean visit(InstanceofExpression node) { 338 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 339 return matches(node); 340 return super.visit(node); 341 } 342 343 @Override visit(Javadoc node)344 public boolean visit(Javadoc node) { 345 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 346 return matches(node); 347 return super.visit(node); 348 } 349 350 @Override visit(LabeledStatement node)351 public boolean visit(LabeledStatement node) { 352 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 353 return matches(node); 354 return super.visit(node); 355 } 356 357 @Override visit(MethodDeclaration node)358 public boolean visit(MethodDeclaration node) { 359 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 360 return matches(node); 361 return super.visit(node); 362 } 363 364 @Override visit(MethodInvocation node)365 public boolean visit(MethodInvocation node) { 366 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 367 return matches(node); 368 return super.visit(node); 369 } 370 371 @Override visit(NullLiteral node)372 public boolean visit(NullLiteral node) { 373 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 374 return matches(node); 375 return super.visit(node); 376 } 377 378 @Override visit(NumberLiteral node)379 public boolean visit(NumberLiteral node) { 380 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 381 return matches(node); 382 return super.visit(node); 383 } 384 385 @Override visit(PackageDeclaration node)386 public boolean visit(PackageDeclaration node) { 387 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 388 return matches(node); 389 return super.visit(node); 390 } 391 392 @Override visit(ParenthesizedExpression node)393 public boolean visit(ParenthesizedExpression node) { 394 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 395 return matches(node); 396 return super.visit(node); 397 } 398 399 @Override visit(PostfixExpression node)400 public boolean visit(PostfixExpression node) { 401 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 402 return matches(node); 403 return super.visit(node); 404 } 405 406 @Override visit(PrefixExpression node)407 public boolean visit(PrefixExpression node) { 408 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 409 return matches(node); 410 return super.visit(node); 411 } 412 413 @Override visit(PrimitiveType node)414 public boolean visit(PrimitiveType node) { 415 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 416 return matches(node); 417 return super.visit(node); 418 } 419 420 @Override visit(QualifiedName node)421 public boolean visit(QualifiedName node) { 422 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 423 return matches(node); 424 return super.visit(node); 425 } 426 427 @Override visit(ReturnStatement node)428 public boolean visit(ReturnStatement node) { 429 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 430 return matches(node); 431 return super.visit(node); 432 } 433 434 @Override visit(SimpleName node)435 public boolean visit(SimpleName node) { 436 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 437 return matches(node); 438 return super.visit(node); 439 } 440 441 @Override visit(SimpleType node)442 public boolean visit(SimpleType node) { 443 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 444 return matches(node); 445 return super.visit(node); 446 } 447 448 @Override visit(SingleVariableDeclaration node)449 public boolean visit(SingleVariableDeclaration node) { 450 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 451 return matches(node); 452 return super.visit(node); 453 } 454 455 @Override visit(StringLiteral node)456 public boolean visit(StringLiteral node) { 457 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 458 return matches(node); 459 return super.visit(node); 460 } 461 462 @Override visit(SuperConstructorInvocation node)463 public boolean visit(SuperConstructorInvocation node) { 464 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 465 return matches(node); 466 return super.visit(node); 467 } 468 469 @Override visit(SuperFieldAccess node)470 public boolean visit(SuperFieldAccess node) { 471 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 472 return matches(node); 473 return super.visit(node); 474 } 475 476 @Override visit(SuperMethodInvocation node)477 public boolean visit(SuperMethodInvocation node) { 478 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 479 return matches(node); 480 return super.visit(node); 481 } 482 483 @Override visit(SwitchCase node)484 public boolean visit(SwitchCase node) { 485 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 486 return matches(node); 487 return super.visit(node); 488 } 489 490 @Override visit(SwitchStatement node)491 public boolean visit(SwitchStatement node) { 492 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 493 return matches(node); 494 return super.visit(node); 495 } 496 497 @Override visit(SynchronizedStatement node)498 public boolean visit(SynchronizedStatement node) { 499 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 500 return matches(node); 501 return super.visit(node); 502 } 503 504 @Override visit(ThisExpression node)505 public boolean visit(ThisExpression node) { 506 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 507 return matches(node); 508 return super.visit(node); 509 } 510 511 @Override visit(ThrowStatement node)512 public boolean visit(ThrowStatement node) { 513 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 514 return matches(node); 515 return super.visit(node); 516 } 517 518 @Override visit(TryStatement node)519 public boolean visit(TryStatement node) { 520 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 521 return matches(node); 522 return super.visit(node); 523 } 524 525 @Override visit(TypeDeclaration node)526 public boolean visit(TypeDeclaration node) { 527 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 528 return matches(node); 529 return super.visit(node); 530 } 531 532 @Override visit(TypeDeclarationStatement node)533 public boolean visit(TypeDeclarationStatement node) { 534 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 535 return matches(node); 536 return super.visit(node); 537 } 538 539 @Override visit(TypeLiteral node)540 public boolean visit(TypeLiteral node) { 541 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 542 return matches(node); 543 return super.visit(node); 544 } 545 546 @Override visit(VariableDeclarationExpression node)547 public boolean visit(VariableDeclarationExpression node) { 548 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 549 return matches(node); 550 return super.visit(node); 551 } 552 553 @Override visit(VariableDeclarationFragment node)554 public boolean visit(VariableDeclarationFragment node) { 555 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 556 return matches(node); 557 return super.visit(node); 558 } 559 560 @Override visit(VariableDeclarationStatement node)561 public boolean visit(VariableDeclarationStatement node) { 562 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 563 return matches(node); 564 return super.visit(node); 565 } 566 567 @Override visit(WhileStatement node)568 public boolean visit(WhileStatement node) { 569 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 570 return matches(node); 571 return super.visit(node); 572 } 573 574 @Override visit(AnnotationTypeDeclaration node)575 public boolean visit(AnnotationTypeDeclaration node) { 576 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 577 return matches(node); 578 return super.visit(node); 579 } 580 581 @Override visit(AnnotationTypeMemberDeclaration node)582 public boolean visit(AnnotationTypeMemberDeclaration node) { 583 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 584 return matches(node); 585 return super.visit(node); 586 } 587 588 @Override visit(BlockComment node)589 public boolean visit(BlockComment node) { 590 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 591 return matches(node); 592 return super.visit(node); 593 } 594 595 @Override visit(EnhancedForStatement node)596 public boolean visit(EnhancedForStatement node) { 597 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 598 return matches(node); 599 return super.visit(node); 600 } 601 602 @Override visit(EnumConstantDeclaration node)603 public boolean visit(EnumConstantDeclaration node) { 604 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 605 return matches(node); 606 return super.visit(node); 607 } 608 609 @Override visit(EnumDeclaration node)610 public boolean visit(EnumDeclaration node) { 611 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 612 return matches(node); 613 return super.visit(node); 614 } 615 616 @Override visit(LineComment node)617 public boolean visit(LineComment node) { 618 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 619 return matches(node); 620 return super.visit(node); 621 } 622 623 @Override visit(MarkerAnnotation node)624 public boolean visit(MarkerAnnotation node) { 625 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 626 return matches(node); 627 return super.visit(node); 628 } 629 630 @Override visit(MemberRef node)631 public boolean visit(MemberRef node) { 632 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 633 return matches(node); 634 return super.visit(node); 635 } 636 637 @Override visit(MemberValuePair node)638 public boolean visit(MemberValuePair node) { 639 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 640 return matches(node); 641 return super.visit(node); 642 } 643 644 @Override visit(MethodRef node)645 public boolean visit(MethodRef node) { 646 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 647 return matches(node); 648 return super.visit(node); 649 } 650 651 @Override visit(MethodRefParameter node)652 public boolean visit(MethodRefParameter node) { 653 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 654 return matches(node); 655 return super.visit(node); 656 } 657 658 @Override visit(Modifier node)659 public boolean visit(Modifier node) { 660 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 661 return matches(node); 662 return super.visit(node); 663 } 664 665 @Override visit(NormalAnnotation node)666 public boolean visit(NormalAnnotation node) { 667 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 668 return matches(node); 669 return super.visit(node); 670 } 671 672 @Override visit(ParameterizedType node)673 public boolean visit(ParameterizedType node) { 674 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 675 return matches(node); 676 return super.visit(node); 677 } 678 679 @Override visit(QualifiedType node)680 public boolean visit(QualifiedType node) { 681 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 682 return matches(node); 683 return super.visit(node); 684 } 685 686 @Override visit(SingleMemberAnnotation node)687 public boolean visit(SingleMemberAnnotation node) { 688 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 689 return matches(node); 690 return super.visit(node); 691 } 692 693 @Override visit(TagElement node)694 public boolean visit(TagElement node) { 695 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 696 return matches(node); 697 return super.visit(node); 698 } 699 700 @Override visit(TextElement node)701 public boolean visit(TextElement node) { 702 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 703 return matches(node); 704 return super.visit(node); 705 } 706 707 @Override visit(TypeParameter node)708 public boolean visit(TypeParameter node) { 709 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 710 return matches(node); 711 return super.visit(node); 712 } 713 714 @Override visit(WildcardType node)715 public boolean visit(WildcardType node) { 716 if (node.subtreeMatch(fMatcher, fNodeToMatch)) 717 return matches(node); 718 return super.visit(node); 719 } 720 } 721 } 722