TreeScanner.java revision 3193:3b3bea483542
1/* 2 * Copyright (c) 2005, 2014, 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 26package com.sun.source.util; 27 28import com.sun.source.tree.*; 29 30/** 31 * A TreeVisitor that visits all the child tree nodes. 32 * To visit nodes of a particular type, just override the 33 * corresponding visitXYZ method. 34 * Inside your method, call super.visitXYZ to visit descendant 35 * nodes. 36 * 37 * <p>The default implementation of the visitXYZ methods will determine 38 * a result as follows: 39 * <ul> 40 * <li>If the node being visited has no children, the result will be {@code null}. 41 * <li>If the node being visited has one child, the result will be the 42 * result of calling {@code scan} on that child. The child may be a simple node 43 * or itself a list of nodes. 44 * <li> If the node being visited has more than one child, the result will 45 * be determined by calling {@code scan} each child in turn, and then combining the 46 * result of each scan after the first with the cumulative result 47 * so far, as determined by the {@link #reduce} method. Each child may be either 48 * a simple node of a list of nodes. The default behavior of the {@code reduce} 49 * method is such that the result of the visitXYZ method will be the result of 50 * the last child scanned. 51 * </ul> 52 * 53 * <p>Here is an example to count the number of identifier nodes in a tree: 54 * <pre> 55 * class CountIdentifiers extends TreeScanner<Integer,Void> { 56 * {@literal @}Override 57 * public Integer visitIdentifier(IdentifierTree node, Void p) { 58 * return 1; 59 * } 60 * {@literal @}Override 61 * public Integer reduce(Integer r1, Integer r2) { 62 * return (r1 == null ? 0 : r1) + (r2 == null ? 0 : r2); 63 * } 64 * } 65 * </pre> 66 * 67 * @param <R> the return type of this visitor's methods. Use {@link 68 * Void} for visitors that do not need to return results. 69 * @param <P> the type of the additional parameter to this visitor's 70 * methods. Use {@code Void} for visitors that do not need an 71 * additional parameter. 72 * 73 * @author Peter von der Ahé 74 * @author Jonathan Gibbons 75 * @since 1.6 76 */ 77public class TreeScanner<R,P> implements TreeVisitor<R,P> { 78 79 /** 80 * Scans a single node. 81 * @param tree the node to be scanned 82 * @param p a parameter value passed to the visit method 83 * @return the result value from the visit method 84 */ 85 public R scan(Tree tree, P p) { 86 return (tree == null) ? null : tree.accept(this, p); 87 } 88 89 private R scanAndReduce(Tree node, P p, R r) { 90 return reduce(scan(node, p), r); 91 } 92 93 /** 94 * Scans a sequence of nodes. 95 * @param nodes the nodes to be scanned 96 * @param p a parameter value to be passed to the visit method for each node 97 * @return the combined return value from the visit methods. 98 * The values are combined using the {@link #reduce reduce} method. 99 */ 100 public R scan(Iterable<? extends Tree> nodes, P p) { 101 R r = null; 102 if (nodes != null) { 103 boolean first = true; 104 for (Tree node : nodes) { 105 r = (first ? scan(node, p) : scanAndReduce(node, p, r)); 106 first = false; 107 } 108 } 109 return r; 110 } 111 112 private R scanAndReduce(Iterable<? extends Tree> nodes, P p, R r) { 113 return reduce(scan(nodes, p), r); 114 } 115 116 /** 117 * Reduces two results into a combined result. 118 * The default implementation is to return the first parameter. 119 * The general contract of the method is that it may take any action whatsoever. 120 * @param r1 the first of the values to be combined 121 * @param r2 the second of the values to be combined 122 * @return the result of combining the two parameters 123 */ 124 public R reduce(R r1, R r2) { 125 return r1; 126 } 127 128 129/* *************************************************************************** 130 * Visitor methods 131 ****************************************************************************/ 132 133 /** 134 * {@inheritDoc} This implementation scans the children in left to right order. 135 * 136 * @param node {@inheritDoc} 137 * @param p {@inheritDoc} 138 * @return the result of scanning 139 */ 140 @Override 141 public R visitCompilationUnit(CompilationUnitTree node, P p) { 142 R r = scan(node.getPackage(), p); 143 r = scanAndReduce(node.getImports(), p, r); 144 r = scanAndReduce(node.getTypeDecls(), p, r); 145 return r; 146 } 147 148 /** 149 * {@inheritDoc} This implementation scans the children in left to right order. 150 * 151 * @param node {@inheritDoc} 152 * @param p {@inheritDoc} 153 * @return the result of scanning 154 */ 155 @Override 156 public R visitPackage(PackageTree node, P p) { 157 R r = scan(node.getAnnotations(), p); 158 r = scanAndReduce(node.getPackageName(), p, r); 159 return r; 160 } 161 162 /** 163 * {@inheritDoc} This implementation scans the children in left to right order. 164 * 165 * @param node {@inheritDoc} 166 * @param p {@inheritDoc} 167 * @return the result of scanning 168 */ 169 @Override 170 public R visitImport(ImportTree node, P p) { 171 return scan(node.getQualifiedIdentifier(), p); 172 } 173 174 /** 175 * {@inheritDoc} This implementation scans the children in left to right order. 176 * 177 * @param node {@inheritDoc} 178 * @param p {@inheritDoc} 179 * @return the result of scanning 180 */ 181 @Override 182 public R visitClass(ClassTree node, P p) { 183 R r = scan(node.getModifiers(), p); 184 r = scanAndReduce(node.getTypeParameters(), p, r); 185 r = scanAndReduce(node.getExtendsClause(), p, r); 186 r = scanAndReduce(node.getImplementsClause(), p, r); 187 r = scanAndReduce(node.getMembers(), p, r); 188 return r; 189 } 190 191 /** 192 * {@inheritDoc} This implementation scans the children in left to right order. 193 * 194 * @param node {@inheritDoc} 195 * @param p {@inheritDoc} 196 * @return the result of scanning 197 */ 198 @Override 199 public R visitMethod(MethodTree node, P p) { 200 R r = scan(node.getModifiers(), p); 201 r = scanAndReduce(node.getReturnType(), p, r); 202 r = scanAndReduce(node.getTypeParameters(), p, r); 203 r = scanAndReduce(node.getParameters(), p, r); 204 r = scanAndReduce(node.getReceiverParameter(), p, r); 205 r = scanAndReduce(node.getThrows(), p, r); 206 r = scanAndReduce(node.getBody(), p, r); 207 r = scanAndReduce(node.getDefaultValue(), p, r); 208 return r; 209 } 210 211 /** 212 * {@inheritDoc} This implementation scans the children in left to right order. 213 * 214 * @param node {@inheritDoc} 215 * @param p {@inheritDoc} 216 * @return the result of scanning 217 */ 218 @Override 219 public R visitVariable(VariableTree node, P p) { 220 R r = scan(node.getModifiers(), p); 221 r = scanAndReduce(node.getType(), p, r); 222 r = scanAndReduce(node.getNameExpression(), p, r); 223 r = scanAndReduce(node.getInitializer(), p, r); 224 return r; 225 } 226 227 /** 228 * {@inheritDoc} This implementation returns {@code null}. 229 * 230 * @param node {@inheritDoc} 231 * @param p {@inheritDoc} 232 * @return the result of scanning 233 */ 234 @Override 235 public R visitEmptyStatement(EmptyStatementTree node, P p) { 236 return null; 237 } 238 239 /** 240 * {@inheritDoc} This implementation scans the children in left to right order. 241 * 242 * @param node {@inheritDoc} 243 * @param p {@inheritDoc} 244 * @return the result of scanning 245 */ 246 @Override 247 public R visitBlock(BlockTree node, P p) { 248 return scan(node.getStatements(), p); 249 } 250 251 /** 252 * {@inheritDoc} This implementation scans the children in left to right order. 253 * 254 * @param node {@inheritDoc} 255 * @param p {@inheritDoc} 256 * @return the result of scanning 257 */ 258 @Override 259 public R visitDoWhileLoop(DoWhileLoopTree node, P p) { 260 R r = scan(node.getStatement(), p); 261 r = scanAndReduce(node.getCondition(), p, r); 262 return r; 263 } 264 265 /** 266 * {@inheritDoc} This implementation scans the children in left to right order. 267 * 268 * @param node {@inheritDoc} 269 * @param p {@inheritDoc} 270 * @return the result of scanning 271 */ 272 @Override 273 public R visitWhileLoop(WhileLoopTree node, P p) { 274 R r = scan(node.getCondition(), p); 275 r = scanAndReduce(node.getStatement(), p, r); 276 return r; 277 } 278 279 /** 280 * {@inheritDoc} This implementation scans the children in left to right order. 281 * 282 * @param node {@inheritDoc} 283 * @param p {@inheritDoc} 284 * @return the result of scanning 285 */ 286 @Override 287 public R visitForLoop(ForLoopTree node, P p) { 288 R r = scan(node.getInitializer(), p); 289 r = scanAndReduce(node.getCondition(), p, r); 290 r = scanAndReduce(node.getUpdate(), p, r); 291 r = scanAndReduce(node.getStatement(), p, r); 292 return r; 293 } 294 295 /** 296 * {@inheritDoc} This implementation scans the children in left to right order. 297 * 298 * @param node {@inheritDoc} 299 * @param p {@inheritDoc} 300 * @return the result of scanning 301 */ 302 @Override 303 public R visitEnhancedForLoop(EnhancedForLoopTree node, P p) { 304 R r = scan(node.getVariable(), p); 305 r = scanAndReduce(node.getExpression(), p, r); 306 r = scanAndReduce(node.getStatement(), p, r); 307 return r; 308 } 309 310 /** 311 * {@inheritDoc} This implementation scans the children in left to right order. 312 * 313 * @param node {@inheritDoc} 314 * @param p {@inheritDoc} 315 * @return the result of scanning 316 */ 317 @Override 318 public R visitLabeledStatement(LabeledStatementTree node, P p) { 319 return scan(node.getStatement(), p); 320 } 321 322 /** 323 * {@inheritDoc} This implementation scans the children in left to right order. 324 * 325 * @param node {@inheritDoc} 326 * @param p {@inheritDoc} 327 * @return the result of scanning 328 */ 329 @Override 330 public R visitSwitch(SwitchTree node, P p) { 331 R r = scan(node.getExpression(), p); 332 r = scanAndReduce(node.getCases(), p, r); 333 return r; 334 } 335 336 /** 337 * {@inheritDoc} This implementation scans the children in left to right order. 338 * 339 * @param node {@inheritDoc} 340 * @param p {@inheritDoc} 341 * @return the result of scanning 342 */ 343 @Override 344 public R visitCase(CaseTree node, P p) { 345 R r = scan(node.getExpression(), p); 346 r = scanAndReduce(node.getStatements(), p, r); 347 return r; 348 } 349 350 /** 351 * {@inheritDoc} This implementation scans the children in left to right order. 352 * 353 * @param node {@inheritDoc} 354 * @param p {@inheritDoc} 355 * @return the result of scanning 356 */ 357 @Override 358 public R visitSynchronized(SynchronizedTree node, P p) { 359 R r = scan(node.getExpression(), p); 360 r = scanAndReduce(node.getBlock(), p, r); 361 return r; 362 } 363 364 /** 365 * {@inheritDoc} This implementation scans the children in left to right order. 366 * 367 * @param node {@inheritDoc} 368 * @param p {@inheritDoc} 369 * @return the result of scanning 370 */ 371 @Override 372 public R visitTry(TryTree node, P p) { 373 R r = scan(node.getResources(), p); 374 r = scanAndReduce(node.getBlock(), p, r); 375 r = scanAndReduce(node.getCatches(), p, r); 376 r = scanAndReduce(node.getFinallyBlock(), p, r); 377 return r; 378 } 379 380 /** 381 * {@inheritDoc} This implementation scans the children in left to right order. 382 * 383 * @param node {@inheritDoc} 384 * @param p {@inheritDoc} 385 * @return the result of scanning 386 */ 387 @Override 388 public R visitCatch(CatchTree node, P p) { 389 R r = scan(node.getParameter(), p); 390 r = scanAndReduce(node.getBlock(), p, r); 391 return r; 392 } 393 394 /** 395 * {@inheritDoc} This implementation scans the children in left to right order. 396 * 397 * @param node {@inheritDoc} 398 * @param p {@inheritDoc} 399 * @return the result of scanning 400 */ 401 @Override 402 public R visitConditionalExpression(ConditionalExpressionTree node, P p) { 403 R r = scan(node.getCondition(), p); 404 r = scanAndReduce(node.getTrueExpression(), p, r); 405 r = scanAndReduce(node.getFalseExpression(), p, r); 406 return r; 407 } 408 409 /** 410 * {@inheritDoc} This implementation scans the children in left to right order. 411 * 412 * @param node {@inheritDoc} 413 * @param p {@inheritDoc} 414 * @return the result of scanning 415 */ 416 @Override 417 public R visitIf(IfTree node, P p) { 418 R r = scan(node.getCondition(), p); 419 r = scanAndReduce(node.getThenStatement(), p, r); 420 r = scanAndReduce(node.getElseStatement(), p, r); 421 return r; 422 } 423 424 /** 425 * {@inheritDoc} This implementation scans the children in left to right order. 426 * 427 * @param node {@inheritDoc} 428 * @param p {@inheritDoc} 429 * @return the result of scanning 430 */ 431 @Override 432 public R visitExpressionStatement(ExpressionStatementTree node, P p) { 433 return scan(node.getExpression(), p); 434 } 435 436 /** 437 * {@inheritDoc} This implementation returns {@code null}. 438 * 439 * @param node {@inheritDoc} 440 * @param p {@inheritDoc} 441 * @return the result of scanning 442 */ 443 @Override 444 public R visitBreak(BreakTree node, P p) { 445 return null; 446 } 447 448 /** 449 * {@inheritDoc} This implementation returns {@code null}. 450 * 451 * @param node {@inheritDoc} 452 * @param p {@inheritDoc} 453 * @return the result of scanning 454 */ 455 @Override 456 public R visitContinue(ContinueTree node, P p) { 457 return null; 458 } 459 460 /** 461 * {@inheritDoc} This implementation scans the children in left to right order. 462 * 463 * @param node {@inheritDoc} 464 * @param p {@inheritDoc} 465 * @return the result of scanning 466 */ 467 @Override 468 public R visitReturn(ReturnTree node, P p) { 469 return scan(node.getExpression(), p); 470 } 471 472 /** 473 * {@inheritDoc} This implementation scans the children in left to right order. 474 * 475 * @param node {@inheritDoc} 476 * @param p {@inheritDoc} 477 * @return the result of scanning 478 */ 479 @Override 480 public R visitThrow(ThrowTree node, P p) { 481 return scan(node.getExpression(), p); 482 } 483 484 /** 485 * {@inheritDoc} This implementation scans the children in left to right order. 486 * 487 * @param node {@inheritDoc} 488 * @param p {@inheritDoc} 489 * @return the result of scanning 490 */ 491 @Override 492 public R visitAssert(AssertTree node, P p) { 493 R r = scan(node.getCondition(), p); 494 r = scanAndReduce(node.getDetail(), p, r); 495 return r; 496 } 497 498 /** 499 * {@inheritDoc} This implementation scans the children in left to right order. 500 * 501 * @param node {@inheritDoc} 502 * @param p {@inheritDoc} 503 * @return the result of scanning 504 */ 505 @Override 506 public R visitMethodInvocation(MethodInvocationTree node, P p) { 507 R r = scan(node.getTypeArguments(), p); 508 r = scanAndReduce(node.getMethodSelect(), p, r); 509 r = scanAndReduce(node.getArguments(), p, r); 510 return r; 511 } 512 513 /** 514 * {@inheritDoc} This implementation scans the children in left to right order. 515 * 516 * @param node {@inheritDoc} 517 * @param p {@inheritDoc} 518 * @return the result of scanning 519 */ 520 @Override 521 public R visitNewClass(NewClassTree node, P p) { 522 R r = scan(node.getEnclosingExpression(), p); 523 r = scanAndReduce(node.getIdentifier(), p, r); 524 r = scanAndReduce(node.getTypeArguments(), p, r); 525 r = scanAndReduce(node.getArguments(), p, r); 526 r = scanAndReduce(node.getClassBody(), p, r); 527 return r; 528 } 529 530 /** 531 * {@inheritDoc} This implementation scans the children in left to right order. 532 * 533 * @param node {@inheritDoc} 534 * @param p {@inheritDoc} 535 * @return the result of scanning 536 */ 537 @Override 538 public R visitNewArray(NewArrayTree node, P p) { 539 R r = scan(node.getType(), p); 540 r = scanAndReduce(node.getDimensions(), p, r); 541 r = scanAndReduce(node.getInitializers(), p, r); 542 r = scanAndReduce(node.getAnnotations(), p, r); 543 for (Iterable< ? extends Tree> dimAnno : node.getDimAnnotations()) { 544 r = scanAndReduce(dimAnno, p, r); 545 } 546 return r; 547 } 548 549 /** 550 * {@inheritDoc} This implementation scans the children in left to right order. 551 * 552 * @param node {@inheritDoc} 553 * @param p {@inheritDoc} 554 * @return the result of scanning 555 */ 556 @Override 557 public R visitLambdaExpression(LambdaExpressionTree node, P p) { 558 R r = scan(node.getParameters(), p); 559 r = scanAndReduce(node.getBody(), p, r); 560 return r; 561 } 562 563 /** 564 * {@inheritDoc} This implementation scans the children in left to right order. 565 * 566 * @param node {@inheritDoc} 567 * @param p {@inheritDoc} 568 * @return the result of scanning 569 */ 570 @Override 571 public R visitParenthesized(ParenthesizedTree node, P p) { 572 return scan(node.getExpression(), p); 573 } 574 575 /** 576 * {@inheritDoc} This implementation scans the children in left to right order. 577 * 578 * @param node {@inheritDoc} 579 * @param p {@inheritDoc} 580 * @return the result of scanning 581 */ 582 @Override 583 public R visitAssignment(AssignmentTree node, P p) { 584 R r = scan(node.getVariable(), p); 585 r = scanAndReduce(node.getExpression(), p, r); 586 return r; 587 } 588 589 /** 590 * {@inheritDoc} This implementation scans the children in left to right order. 591 * 592 * @param node {@inheritDoc} 593 * @param p {@inheritDoc} 594 * @return the result of scanning 595 */ 596 @Override 597 public R visitCompoundAssignment(CompoundAssignmentTree node, P p) { 598 R r = scan(node.getVariable(), p); 599 r = scanAndReduce(node.getExpression(), p, r); 600 return r; 601 } 602 603 /** 604 * {@inheritDoc} This implementation scans the children in left to right order. 605 * 606 * @param node {@inheritDoc} 607 * @param p {@inheritDoc} 608 * @return the result of scanning 609 */ 610 @Override 611 public R visitUnary(UnaryTree node, P p) { 612 return scan(node.getExpression(), p); 613 } 614 615 /** 616 * {@inheritDoc} This implementation scans the children in left to right order. 617 * 618 * @param node {@inheritDoc} 619 * @param p {@inheritDoc} 620 * @return the result of scanning 621 */ 622 @Override 623 public R visitBinary(BinaryTree node, P p) { 624 R r = scan(node.getLeftOperand(), p); 625 r = scanAndReduce(node.getRightOperand(), p, r); 626 return r; 627 } 628 629 /** 630 * {@inheritDoc} This implementation scans the children in left to right order. 631 * 632 * @param node {@inheritDoc} 633 * @param p {@inheritDoc} 634 * @return the result of scanning 635 */ 636 @Override 637 public R visitTypeCast(TypeCastTree node, P p) { 638 R r = scan(node.getType(), p); 639 r = scanAndReduce(node.getExpression(), p, r); 640 return r; 641 } 642 643 /** 644 * {@inheritDoc} This implementation scans the children in left to right order. 645 * 646 * @param node {@inheritDoc} 647 * @param p {@inheritDoc} 648 * @return the result of scanning 649 */ 650 @Override 651 public R visitInstanceOf(InstanceOfTree node, P p) { 652 R r = scan(node.getExpression(), p); 653 r = scanAndReduce(node.getType(), p, r); 654 return r; 655 } 656 657 /** 658 * {@inheritDoc} This implementation scans the children in left to right order. 659 * 660 * @param node {@inheritDoc} 661 * @param p {@inheritDoc} 662 * @return the result of scanning 663 */ 664 @Override 665 public R visitArrayAccess(ArrayAccessTree node, P p) { 666 R r = scan(node.getExpression(), p); 667 r = scanAndReduce(node.getIndex(), p, r); 668 return r; 669 } 670 671 /** 672 * {@inheritDoc} This implementation scans the children in left to right order. 673 * 674 * @param node {@inheritDoc} 675 * @param p {@inheritDoc} 676 * @return the result of scanning 677 */ 678 @Override 679 public R visitMemberSelect(MemberSelectTree node, P p) { 680 return scan(node.getExpression(), p); 681 } 682 683 /** 684 * {@inheritDoc} This implementation scans the children in left to right order. 685 * 686 * @param node {@inheritDoc} 687 * @param p {@inheritDoc} 688 * @return the result of scanning 689 */ 690 @Override 691 public R visitMemberReference(MemberReferenceTree node, P p) { 692 R r = scan(node.getQualifierExpression(), p); 693 r = scanAndReduce(node.getTypeArguments(), p, r); 694 return r; 695 } 696 697 /** 698 * {@inheritDoc} This implementation returns {@code null}. 699 * 700 * @param node {@inheritDoc} 701 * @param p {@inheritDoc} 702 * @return the result of scanning 703 */ 704 @Override 705 public R visitIdentifier(IdentifierTree node, P p) { 706 return null; 707 } 708 709 /** 710 * {@inheritDoc} This implementation returns {@code null}. 711 * 712 * @param node {@inheritDoc} 713 * @param p {@inheritDoc} 714 * @return the result of scanning 715 */ 716 @Override 717 public R visitLiteral(LiteralTree node, P p) { 718 return null; 719 } 720 721 /** 722 * {@inheritDoc} This implementation returns {@code null}. 723 * 724 * @param node {@inheritDoc} 725 * @param p {@inheritDoc} 726 * @return the result of scanning 727 */ 728 @Override 729 public R visitPrimitiveType(PrimitiveTypeTree node, P p) { 730 return null; 731 } 732 733 /** 734 * {@inheritDoc} This implementation scans the children in left to right order. 735 * 736 * @param node {@inheritDoc} 737 * @param p {@inheritDoc} 738 * @return the result of scanning 739 */ 740 @Override 741 public R visitArrayType(ArrayTypeTree node, P p) { 742 return scan(node.getType(), p); 743 } 744 745 /** 746 * {@inheritDoc} This implementation scans the children in left to right order. 747 * 748 * @param node {@inheritDoc} 749 * @param p {@inheritDoc} 750 * @return the result of scanning 751 */ 752 @Override 753 public R visitParameterizedType(ParameterizedTypeTree node, P p) { 754 R r = scan(node.getType(), p); 755 r = scanAndReduce(node.getTypeArguments(), p, r); 756 return r; 757 } 758 759 /** 760 * {@inheritDoc} This implementation scans the children in left to right order. 761 * 762 * @param node {@inheritDoc} 763 * @param p {@inheritDoc} 764 * @return the result of scanning 765 */ 766 @Override 767 public R visitUnionType(UnionTypeTree node, P p) { 768 return scan(node.getTypeAlternatives(), p); 769 } 770 771 /** 772 * {@inheritDoc} This implementation scans the children in left to right order. 773 * 774 * @param node {@inheritDoc} 775 * @param p {@inheritDoc} 776 * @return the result of scanning 777 */ 778 @Override 779 public R visitIntersectionType(IntersectionTypeTree node, P p) { 780 return scan(node.getBounds(), p); 781 } 782 783 /** 784 * {@inheritDoc} This implementation scans the children in left to right order. 785 * 786 * @param node {@inheritDoc} 787 * @param p {@inheritDoc} 788 * @return the result of scanning 789 */ 790 @Override 791 public R visitTypeParameter(TypeParameterTree node, P p) { 792 R r = scan(node.getAnnotations(), p); 793 r = scanAndReduce(node.getBounds(), p, r); 794 return r; 795 } 796 797 /** 798 * {@inheritDoc} This implementation scans the children in left to right order. 799 * 800 * @param node {@inheritDoc} 801 * @param p {@inheritDoc} 802 * @return the result of scanning 803 */ 804 @Override 805 public R visitWildcard(WildcardTree node, P p) { 806 return scan(node.getBound(), p); 807 } 808 809 /** 810 * {@inheritDoc} This implementation scans the children in left to right order. 811 * 812 * @param node {@inheritDoc} 813 * @param p {@inheritDoc} 814 * @return the result of scanning 815 */ 816 @Override 817 public R visitModifiers(ModifiersTree node, P p) { 818 return scan(node.getAnnotations(), p); 819 } 820 821 /** 822 * {@inheritDoc} This implementation scans the children in left to right order. 823 * 824 * @param node {@inheritDoc} 825 * @param p {@inheritDoc} 826 * @return the result of scanning 827 */ 828 @Override 829 public R visitAnnotation(AnnotationTree node, P p) { 830 R r = scan(node.getAnnotationType(), p); 831 r = scanAndReduce(node.getArguments(), p, r); 832 return r; 833 } 834 835 /** 836 * {@inheritDoc} This implementation scans the children in left to right order. 837 * 838 * @param node {@inheritDoc} 839 * @param p {@inheritDoc} 840 * @return the result of scanning 841 */ 842 @Override 843 public R visitAnnotatedType(AnnotatedTypeTree node, P p) { 844 R r = scan(node.getAnnotations(), p); 845 r = scanAndReduce(node.getUnderlyingType(), p, r); 846 return r; 847 } 848 849 /** 850 * {@inheritDoc} This implementation returns {@code null}. 851 * 852 * @param node {@inheritDoc} 853 * @param p {@inheritDoc} 854 * @return the result of scanning 855 */ 856 @Override 857 public R visitOther(Tree node, P p) { 858 return null; 859 } 860 861 /** 862 * {@inheritDoc} This implementation returns {@code null}. 863 * 864 * @param node {@inheritDoc} 865 * @param p {@inheritDoc} 866 * @return the result of scanning 867 */ 868 @Override 869 public R visitErroneous(ErroneousTree node, P p) { 870 return null; 871 } 872} 873