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.tree;
  27 
  28 /**
  29  * Common interface for all nodes in an abstract syntax tree.
  30  *
  31  * <p><b>WARNING:</b> This interface and its sub-interfaces are
  32  * subject to change as the Java&trade; programming language evolves.
  33  * These interfaces are implemented by the JDK Java compiler (javac)
  34  * and should not be implemented either directly or indirectly by
  35  * other applications.
  36  *
  37  * @author Peter von der Ah&eacute;
  38  * @author Jonathan Gibbons
  39  *
  40  * @since 1.6
  41  */
  42 public interface Tree {
  43 
  44     /**
  45      * Enumerates all kinds of trees.
  46      */
  47     public enum Kind {
  48         /**
  49          * Used for instances of {@link AnnotatedTypeTree}
  50          * representing annotated types.
  51          */
  52         ANNOTATED_TYPE(AnnotatedTypeTree.class),
  53 
  54         /**
  55          * Used for instances of {@link AnnotationTree}
  56          * representing declaration annotations.
  57          */
  58         ANNOTATION(AnnotationTree.class),
  59 
  60         /**
  61          * Used for instances of {@link AnnotationTree}
  62          * representing type annotations.
  63          */
  64         TYPE_ANNOTATION(AnnotationTree.class),
  65 
  66         /**
  67          * Used for instances of {@link ArrayAccessTree}.
  68          */
  69         ARRAY_ACCESS(ArrayAccessTree.class),
  70 
  71         /**
  72          * Used for instances of {@link ArrayTypeTree}.
  73          */
  74         ARRAY_TYPE(ArrayTypeTree.class),
  75 
  76         /**
  77          * Used for instances of {@link AssertTree}.
  78          */
  79         ASSERT(AssertTree.class),
  80 
  81         /**
  82          * Used for instances of {@link AssignmentTree}.
  83          */
  84         ASSIGNMENT(AssignmentTree.class),
  85 
  86         /**
  87          * Used for instances of {@link BlockTree}.
  88          */
  89         BLOCK(BlockTree.class),
  90 
  91         /**
  92          * Used for instances of {@link BreakTree}.
  93          */
  94         BREAK(BreakTree.class),
  95 
  96         /**
  97          * Used for instances of {@link CaseTree}.
  98          */
  99         CASE(CaseTree.class),
 100 
 101         /**
 102          * Used for instances of {@link CatchTree}.
 103          */
 104         CATCH(CatchTree.class),
 105 
 106         /**
 107          * Used for instances of {@link ClassTree} representing classes.
 108          */
 109         CLASS(ClassTree.class),
 110 
 111         /**
 112          * Used for instances of {@link CompilationUnitTree}.
 113          */
 114         COMPILATION_UNIT(CompilationUnitTree.class),
 115 
 116         /**
 117          * Used for instances of {@link ConditionalExpressionTree}.
 118          */
 119         CONDITIONAL_EXPRESSION(ConditionalExpressionTree.class),
 120 
 121         /**
 122          * Used for instances of {@link ContinueTree}.
 123          */
 124         CONTINUE(ContinueTree.class),
 125 
 126         /**
 127          * Used for instances of {@link DoWhileLoopTree}.
 128          */
 129         DO_WHILE_LOOP(DoWhileLoopTree.class),
 130 
 131         /**
 132          * Used for instances of {@link EnhancedForLoopTree}.
 133          */
 134         ENHANCED_FOR_LOOP(EnhancedForLoopTree.class),
 135 
 136         /**
 137          * Used for instances of {@link ExpressionStatementTree}.
 138          */
 139         EXPRESSION_STATEMENT(ExpressionStatementTree.class),
 140 
 141         /**
 142          * Used for instances of {@link MemberSelectTree}.
 143          */
 144         MEMBER_SELECT(MemberSelectTree.class),
 145 
 146         /**
 147          * Used for instances of {@link MemberReferenceTree}.
 148          */
 149         MEMBER_REFERENCE(MemberReferenceTree.class),
 150 
 151         /**
 152          * Used for instances of {@link ForLoopTree}.
 153          */
 154         FOR_LOOP(ForLoopTree.class),
 155 
 156         /**
 157          * Used for instances of {@link IdentifierTree}.
 158          */
 159         IDENTIFIER(IdentifierTree.class),
 160 
 161         /**
 162          * Used for instances of {@link IfTree}.
 163          */
 164         IF(IfTree.class),
 165 
 166         /**
 167          * Used for instances of {@link ImportTree}.
 168          */
 169         IMPORT(ImportTree.class),
 170 
 171         /**
 172          * Used for instances of {@link InstanceOfTree}.
 173          */
 174         INSTANCE_OF(InstanceOfTree.class),
 175 
 176         /**
 177          * Used for instances of {@link LabeledStatementTree}.
 178          */
 179         LABELED_STATEMENT(LabeledStatementTree.class),
 180 
 181         /**
 182          * Used for instances of {@link MethodTree}.
 183          */
 184         METHOD(MethodTree.class),
 185 
 186         /**
 187          * Used for instances of {@link MethodInvocationTree}.
 188          */
 189         METHOD_INVOCATION(MethodInvocationTree.class),
 190 
 191         /**
 192          * Used for instances of {@link ModifiersTree}.
 193          */
 194         MODIFIERS(ModifiersTree.class),
 195 
 196         /**
 197          * Used for instances of {@link NewArrayTree}.
 198          */
 199         NEW_ARRAY(NewArrayTree.class),
 200 
 201         /**
 202          * Used for instances of {@link NewClassTree}.
 203          */
 204         NEW_CLASS(NewClassTree.class),
 205 
 206         /**
 207          * Used for instances of {@link LambdaExpressionTree}.
 208          */
 209         LAMBDA_EXPRESSION(LambdaExpressionTree.class),
 210 
 211         /**
 212          * Used for instances of {@link PackageTree}.
 213          * @since 9
 214          */
 215         PACKAGE(PackageTree.class),
 216 
 217         /**
 218          * Used for instances of {@link ParenthesizedTree}.
 219          */
 220         PARENTHESIZED(ParenthesizedTree.class),
 221 
 222         /**
 223          * Used for instances of {@link PrimitiveTypeTree}.
 224          */
 225         PRIMITIVE_TYPE(PrimitiveTypeTree.class),
 226 
 227         /**
 228          * Used for instances of {@link ReturnTree}.
 229          */
 230         RETURN(ReturnTree.class),
 231 
 232         /**
 233          * Used for instances of {@link EmptyStatementTree}.
 234          */
 235         EMPTY_STATEMENT(EmptyStatementTree.class),
 236 
 237         /**
 238          * Used for instances of {@link SwitchTree}.
 239          */
 240         SWITCH(SwitchTree.class),
 241 
 242         /**
 243          * Used for instances of {@link SwitchExpressionTree}.
 244          *
 245          * @since 12
 246          *
 247          * @deprecated
 248          * This enum constant is modeling switch expressions,
 249          * which are part of a preview feature and may be removed
 250          * if the preview feature is removed.
 251          */
 252         @Deprecated(forRemoval=true, since="12")
 253         @SuppressWarnings("removal")
 254         SWITCH_EXPRESSION(SwitchExpressionTree.class),
 255 
 256         /**
 257          * Used for instances of {@link SynchronizedTree}.
 258          */
 259         SYNCHRONIZED(SynchronizedTree.class),
 260 
 261         /**
 262          * Used for instances of {@link ThrowTree}.
 263          */
 264         THROW(ThrowTree.class),
 265 
 266         /**
 267          * Used for instances of {@link TryTree}.
 268          */
 269         TRY(TryTree.class),
 270 
 271         /**
 272          * Used for instances of {@link ParameterizedTypeTree}.
 273          */
 274         PARAMETERIZED_TYPE(ParameterizedTypeTree.class),
 275 
 276         /**
 277          * Used for instances of {@link UnionTypeTree}.
 278          */
 279         UNION_TYPE(UnionTypeTree.class),
 280 
 281         /**
 282          * Used for instances of {@link IntersectionTypeTree}.
 283          */
 284         INTERSECTION_TYPE(IntersectionTypeTree.class),
 285 
 286         /**
 287          * Used for instances of {@link TypeCastTree}.
 288          */
 289         TYPE_CAST(TypeCastTree.class),
 290 
 291         /**
 292          * Used for instances of {@link TypeParameterTree}.
 293          */
 294         TYPE_PARAMETER(TypeParameterTree.class),
 295 
 296         /**
 297          * Used for instances of {@link VariableTree}.
 298          */
 299         VARIABLE(VariableTree.class),
 300 
 301         /**
 302          * Used for instances of {@link WhileLoopTree}.
 303          */
 304         WHILE_LOOP(WhileLoopTree.class),
 305 
 306         /**
 307          * Used for instances of {@link UnaryTree} representing postfix
 308          * increment operator {@code ++}.
 309          */
 310         POSTFIX_INCREMENT(UnaryTree.class),
 311 
 312         /**
 313          * Used for instances of {@link UnaryTree} representing postfix
 314          * decrement operator {@code --}.
 315          */
 316         POSTFIX_DECREMENT(UnaryTree.class),
 317 
 318         /**
 319          * Used for instances of {@link UnaryTree} representing prefix
 320          * increment operator {@code ++}.
 321          */
 322         PREFIX_INCREMENT(UnaryTree.class),
 323 
 324         /**
 325          * Used for instances of {@link UnaryTree} representing prefix
 326          * decrement operator {@code --}.
 327          */
 328         PREFIX_DECREMENT(UnaryTree.class),
 329 
 330         /**
 331          * Used for instances of {@link UnaryTree} representing unary plus
 332          * operator {@code +}.
 333          */
 334         UNARY_PLUS(UnaryTree.class),
 335 
 336         /**
 337          * Used for instances of {@link UnaryTree} representing unary minus
 338          * operator {@code -}.
 339          */
 340         UNARY_MINUS(UnaryTree.class),
 341 
 342         /**
 343          * Used for instances of {@link UnaryTree} representing bitwise
 344          * complement operator {@code ~}.
 345          */
 346         BITWISE_COMPLEMENT(UnaryTree.class),
 347 
 348         /**
 349          * Used for instances of {@link UnaryTree} representing logical
 350          * complement operator {@code !}.
 351          */
 352         LOGICAL_COMPLEMENT(UnaryTree.class),
 353 
 354         /**
 355          * Used for instances of {@link BinaryTree} representing
 356          * multiplication {@code *}.
 357          */
 358         MULTIPLY(BinaryTree.class),
 359 
 360         /**
 361          * Used for instances of {@link BinaryTree} representing
 362          * division {@code /}.
 363          */
 364         DIVIDE(BinaryTree.class),
 365 
 366         /**
 367          * Used for instances of {@link BinaryTree} representing
 368          * remainder {@code %}.
 369          */
 370         REMAINDER(BinaryTree.class),
 371 
 372         /**
 373          * Used for instances of {@link BinaryTree} representing
 374          * addition or string concatenation {@code +}.
 375          */
 376         PLUS(BinaryTree.class),
 377 
 378         /**
 379          * Used for instances of {@link BinaryTree} representing
 380          * subtraction {@code -}.
 381          */
 382         MINUS(BinaryTree.class),
 383 
 384         /**
 385          * Used for instances of {@link BinaryTree} representing
 386          * left shift {@code <<}.
 387          */
 388         LEFT_SHIFT(BinaryTree.class),
 389 
 390         /**
 391          * Used for instances of {@link BinaryTree} representing
 392          * right shift {@code >>}.
 393          */
 394         RIGHT_SHIFT(BinaryTree.class),
 395 
 396         /**
 397          * Used for instances of {@link BinaryTree} representing
 398          * unsigned right shift {@code >>>}.
 399          */
 400         UNSIGNED_RIGHT_SHIFT(BinaryTree.class),
 401 
 402         /**
 403          * Used for instances of {@link BinaryTree} representing
 404          * less-than {@code <}.
 405          */
 406         LESS_THAN(BinaryTree.class),
 407 
 408         /**
 409          * Used for instances of {@link BinaryTree} representing
 410          * greater-than {@code >}.
 411          */
 412         GREATER_THAN(BinaryTree.class),
 413 
 414         /**
 415          * Used for instances of {@link BinaryTree} representing
 416          * less-than-equal {@code <=}.
 417          */
 418         LESS_THAN_EQUAL(BinaryTree.class),
 419 
 420         /**
 421          * Used for instances of {@link BinaryTree} representing
 422          * greater-than-equal {@code >=}.
 423          */
 424         GREATER_THAN_EQUAL(BinaryTree.class),
 425 
 426         /**
 427          * Used for instances of {@link BinaryTree} representing
 428          * equal-to {@code ==}.
 429          */
 430         EQUAL_TO(BinaryTree.class),
 431 
 432         /**
 433          * Used for instances of {@link BinaryTree} representing
 434          * not-equal-to {@code !=}.
 435          */
 436         NOT_EQUAL_TO(BinaryTree.class),
 437 
 438         /**
 439          * Used for instances of {@link BinaryTree} representing
 440          * bitwise and logical "and" {@code &}.
 441          */
 442         AND(BinaryTree.class),
 443 
 444         /**
 445          * Used for instances of {@link BinaryTree} representing
 446          * bitwise and logical "xor" {@code ^}.
 447          */
 448         XOR(BinaryTree.class),
 449 
 450         /**
 451          * Used for instances of {@link BinaryTree} representing
 452          * bitwise and logical "or" {@code |}.
 453          */
 454         OR(BinaryTree.class),
 455 
 456         /**
 457          * Used for instances of {@link BinaryTree} representing
 458          * conditional-and {@code &&}.
 459          */
 460         CONDITIONAL_AND(BinaryTree.class),
 461 
 462         /**
 463          * Used for instances of {@link BinaryTree} representing
 464          * conditional-or {@code ||}.
 465          */
 466         CONDITIONAL_OR(BinaryTree.class),
 467 
 468         /**
 469          * Used for instances of {@link CompoundAssignmentTree} representing
 470          * multiplication assignment {@code *=}.
 471          */
 472         MULTIPLY_ASSIGNMENT(CompoundAssignmentTree.class),
 473 
 474         /**
 475          * Used for instances of {@link CompoundAssignmentTree} representing
 476          * division assignment {@code /=}.
 477          */
 478         DIVIDE_ASSIGNMENT(CompoundAssignmentTree.class),
 479 
 480         /**
 481          * Used for instances of {@link CompoundAssignmentTree} representing
 482          * remainder assignment {@code %=}.
 483          */
 484         REMAINDER_ASSIGNMENT(CompoundAssignmentTree.class),
 485 
 486         /**
 487          * Used for instances of {@link CompoundAssignmentTree} representing
 488          * addition or string concatenation assignment {@code +=}.
 489          */
 490         PLUS_ASSIGNMENT(CompoundAssignmentTree.class),
 491 
 492         /**
 493          * Used for instances of {@link CompoundAssignmentTree} representing
 494          * subtraction assignment {@code -=}.
 495          */
 496         MINUS_ASSIGNMENT(CompoundAssignmentTree.class),
 497 
 498         /**
 499          * Used for instances of {@link CompoundAssignmentTree} representing
 500          * left shift assignment {@code <<=}.
 501          */
 502         LEFT_SHIFT_ASSIGNMENT(CompoundAssignmentTree.class),
 503 
 504         /**
 505          * Used for instances of {@link CompoundAssignmentTree} representing
 506          * right shift assignment {@code >>=}.
 507          */
 508         RIGHT_SHIFT_ASSIGNMENT(CompoundAssignmentTree.class),
 509 
 510         /**
 511          * Used for instances of {@link CompoundAssignmentTree} representing
 512          * unsigned right shift assignment {@code >>>=}.
 513          */
 514         UNSIGNED_RIGHT_SHIFT_ASSIGNMENT(CompoundAssignmentTree.class),
 515 
 516         /**
 517          * Used for instances of {@link CompoundAssignmentTree} representing
 518          * bitwise and logical "and" assignment {@code &=}.
 519          */
 520         AND_ASSIGNMENT(CompoundAssignmentTree.class),
 521 
 522         /**
 523          * Used for instances of {@link CompoundAssignmentTree} representing
 524          * bitwise and logical "xor" assignment {@code ^=}.
 525          */
 526         XOR_ASSIGNMENT(CompoundAssignmentTree.class),
 527 
 528         /**
 529          * Used for instances of {@link CompoundAssignmentTree} representing
 530          * bitwise and logical "or" assignment {@code |=}.
 531          */
 532         OR_ASSIGNMENT(CompoundAssignmentTree.class),
 533 
 534         /**
 535          * Used for instances of {@link LiteralTree} representing
 536          * an integral literal expression of type {@code int}.
 537          */
 538         INT_LITERAL(LiteralTree.class),
 539 
 540         /**
 541          * Used for instances of {@link LiteralTree} representing
 542          * an integral literal expression of type {@code long}.
 543          */
 544         LONG_LITERAL(LiteralTree.class),
 545 
 546         /**
 547          * Used for instances of {@link LiteralTree} representing
 548          * a floating-point literal expression of type {@code float}.
 549          */
 550         FLOAT_LITERAL(LiteralTree.class),
 551 
 552         /**
 553          * Used for instances of {@link LiteralTree} representing
 554          * a floating-point literal expression of type {@code double}.
 555          */
 556         DOUBLE_LITERAL(LiteralTree.class),
 557 
 558         /**
 559          * Used for instances of {@link LiteralTree} representing
 560          * a boolean literal expression of type {@code boolean}.
 561          */
 562         BOOLEAN_LITERAL(LiteralTree.class),
 563 
 564         /**
 565          * Used for instances of {@link LiteralTree} representing
 566          * a character literal expression of type {@code char}.
 567          */
 568         CHAR_LITERAL(LiteralTree.class),
 569 
 570         /**
 571          * Used for instances of {@link LiteralTree} representing
 572          * a string literal expression of type {@link String}.
 573          */
 574         STRING_LITERAL(LiteralTree.class),
 575 
 576         /**
 577          * Used for instances of {@link LiteralTree} representing
 578          * the use of {@code null}.
 579          */
 580         NULL_LITERAL(LiteralTree.class),
 581 
 582         /**
 583          * Used for instances of {@link WildcardTree} representing
 584          * an unbounded wildcard type argument.
 585          */
 586         UNBOUNDED_WILDCARD(WildcardTree.class),
 587 
 588         /**
 589          * Used for instances of {@link WildcardTree} representing
 590          * an extends bounded wildcard type argument.
 591          */
 592         EXTENDS_WILDCARD(WildcardTree.class),
 593 
 594         /**
 595          * Used for instances of {@link WildcardTree} representing
 596          * a super bounded wildcard type argument.
 597          */
 598         SUPER_WILDCARD(WildcardTree.class),
 599 
 600         /**
 601          * Used for instances of {@link ErroneousTree}.
 602          */
 603         ERRONEOUS(ErroneousTree.class),
 604 
 605         /**
 606          * Used for instances of {@link ClassTree} representing interfaces.
 607          */
 608         INTERFACE(ClassTree.class),
 609 
 610         /**
 611          * Used for instances of {@link ClassTree} representing enums.
 612          */
 613         ENUM(ClassTree.class),
 614 
 615         /**
 616          * Used for instances of {@link ClassTree} representing annotation types.
 617          */
 618         ANNOTATION_TYPE(ClassTree.class),
 619 
 620         /**
 621          * Used for instances of {@link ModuleTree} representing module declarations.
 622          */
 623         MODULE(ModuleTree.class),
 624 
 625         /**
 626          * Used for instances of {@link ExportsTree} representing
 627          * exports directives in a module declaration.
 628          */
 629         EXPORTS(ExportsTree.class),
 630 
 631         /**
 632          * Used for instances of {@link ExportsTree} representing
 633          * opens directives in a module declaration.
 634          */
 635         OPENS(OpensTree.class),
 636 
 637         /**
 638          * Used for instances of {@link ProvidesTree} representing
 639          * provides directives in a module declaration.
 640          */
 641         PROVIDES(ProvidesTree.class),
 642 
 643         /**
 644          * Used for instances of {@link RequiresTree} representing
 645          * requires directives in a module declaration.
 646          */
 647         REQUIRES(RequiresTree.class),
 648 
 649         /**
 650          * Used for instances of {@link UsesTree} representing
 651          * uses directives in a module declaration.
 652          */
 653         USES(UsesTree.class),
 654 
 655         /**
 656          * An implementation-reserved node. This is the not the node
 657          * you are looking for.
 658          */
 659         OTHER(null),
 660 
 661         /**
 662          * Used for instances of {@link YieldTree}.
 663          *
 664          * @since 13
 665          *
 666          * @deprecated
 667          * This enum constant is modeling yield statement,
 668          * which are part of a preview feature and may be removed
 669          * if the preview feature is removed.
 670          */
 671         @Deprecated(forRemoval=true, since="13")
 672         @SuppressWarnings("removal")
 673         YIELD(YieldTree.class);
 674 
 675 
 676         Kind(Class<? extends Tree> intf) {
 677             associatedInterface = intf;
 678         }
 679 
 680         /**
 681          * Returns the associated interface type that uses this kind.
 682          * @return the associated interface
 683          */
 684         public Class<? extends Tree> asInterface() {
 685             return associatedInterface;
 686         }
 687 
 688         private final Class<? extends Tree> associatedInterface;
 689     }
 690 
 691     /**
 692      * Returns the kind of this tree.
 693      *
 694      * @return the kind of this tree.
 695      */
 696     Kind getKind();
 697 
 698     /**
 699      * Accept method used to implement the visitor pattern.  The
 700      * visitor pattern is used to implement operations on trees.
 701      *
 702      * @param <R> result type of this operation.
 703      * @param <D> type of additional data.
 704      * @param visitor the visitor to be called
 705      * @param data a value to be passed to the visitor
 706      * @return the result returned from calling the visitor
 707      */
 708     <R,D> R accept(TreeVisitor<R,D> visitor, D data);
 709 }