1 /* 2 * Copyright (c) 1999, 2018, 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.tools.javac.tree; 27 28 import java.io.IOException; 29 import java.io.StringWriter; 30 import java.util.*; 31 32 import javax.lang.model.element.Modifier; 33 import javax.lang.model.type.TypeKind; 34 import javax.tools.JavaFileObject; 35 36 import com.sun.source.tree.*; 37 import com.sun.tools.javac.code.*; 38 import com.sun.tools.javac.code.Directive.RequiresDirective; 39 import com.sun.tools.javac.code.Scope.*; 40 import com.sun.tools.javac.code.Symbol.*; 41 import com.sun.tools.javac.util.*; 42 import com.sun.tools.javac.util.DefinedBy.Api; 43 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition; 44 import com.sun.tools.javac.util.List; 45 46 import static com.sun.tools.javac.tree.JCTree.Tag.*; 47 48 import javax.tools.JavaFileManager.Location; 49 50 import com.sun.source.tree.CaseTree.CaseKind; 51 import com.sun.source.tree.ModuleTree.ModuleKind; 52 import com.sun.tools.javac.code.Directive.ExportsDirective; 53 import com.sun.tools.javac.code.Directive.OpensDirective; 54 import com.sun.tools.javac.code.Type.ModuleType; 55 import com.sun.tools.javac.tree.JCTree.JCPolyExpression.PolyKind; 56 57 /** 58 * Root class for abstract syntax tree nodes. It provides definitions 59 * for specific tree nodes as subclasses nested inside. 60 * 61 * <p>Each subclass is highly standardized. It generally contains 62 * only tree fields for the syntactic subcomponents of the node. Some 63 * classes that represent identifier uses or definitions also define a 64 * Symbol field that denotes the represented identifier. Classes for 65 * non-local jumps also carry the jump target as a field. The root 66 * class Tree itself defines fields for the tree's type and position. 67 * No other fields are kept in a tree node; instead parameters are 68 * passed to methods accessing the node. 69 * 70 * <p>Except for the methods defined by com.sun.source, the only 71 * method defined in subclasses is `visit' which applies a given 72 * visitor to the tree. The actual tree processing is done by visitor 73 * classes in other packages. The abstract class Visitor, as well as 74 * an Factory interface for trees, are defined as inner classes in 75 * Tree. 76 * 77 * <p>To avoid ambiguities with the Tree API in com.sun.source all sub 78 * classes should, by convention, start with JC (javac). 79 * 80 * <p><b>This is NOT part of any supported API. 81 * If you write code that depends on this, you do so at your own risk. 82 * This code and its internal interfaces are subject to change or 83 * deletion without notice.</b> 84 * 85 * @see TreeMaker 86 * @see TreeInfo 87 * @see TreeTranslator 88 * @see Pretty 89 */ 90 public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition { 91 92 /* Tree tag values, identifying kinds of trees */ 93 public enum Tag { 94 /** For methods that return an invalid tag if a given condition is not met 95 */ 96 NO_TAG, 97 98 /** Toplevel nodes, of type TopLevel, representing entire source files. 99 */ 100 TOPLEVEL, 101 102 /** Package level definitions. 103 */ 104 PACKAGEDEF, 105 106 /** Import clauses, of type Import. 107 */ 108 IMPORT, 109 110 /** Class definitions, of type ClassDef. 111 */ 112 CLASSDEF, 113 114 /** Method definitions, of type MethodDef. 115 */ 116 METHODDEF, 117 118 /** Variable definitions, of type VarDef. 119 */ 120 VARDEF, 121 122 /** The no-op statement ";", of type Skip 123 */ 124 SKIP, 125 126 /** Blocks, of type Block. 127 */ 128 BLOCK, 129 130 /** Do-while loops, of type DoLoop. 131 */ 132 DOLOOP, 133 134 /** While-loops, of type WhileLoop. 135 */ 136 WHILELOOP, 137 138 /** For-loops, of type ForLoop. 139 */ 140 FORLOOP, 141 142 /** Foreach-loops, of type ForeachLoop. 143 */ 144 FOREACHLOOP, 145 146 /** Labelled statements, of type Labelled. 147 */ 148 LABELLED, 149 150 /** Switch statements, of type Switch. 151 */ 152 SWITCH, 153 154 /** Case parts in switch statements/expressions, of type Case. 155 */ 156 CASE, 157 158 /** Switch expression statements, of type Switch. 159 */ 160 SWITCH_EXPRESSION, 161 162 /** Synchronized statements, of type Synchonized. 163 */ 164 SYNCHRONIZED, 165 166 /** Try statements, of type Try. 167 */ 168 TRY, 169 170 /** Catch clauses in try statements, of type Catch. 171 */ 172 CATCH, 173 174 /** Conditional expressions, of type Conditional. 175 */ 176 CONDEXPR, 177 178 /** Conditional statements, of type If. 179 */ 180 IF, 181 182 /** Expression statements, of type Exec. 183 */ 184 EXEC, 185 186 /** Break statements, of type Break. 187 */ 188 BREAK, 189 190 /** Continue statements, of type Continue. 191 */ 192 CONTINUE, 193 194 /** Return statements, of type Return. 195 */ 196 RETURN, 197 198 /** Throw statements, of type Throw. 199 */ 200 THROW, 201 202 /** Assert statements, of type Assert. 203 */ 204 ASSERT, 205 206 /** Method invocation expressions, of type Apply. 207 */ 208 APPLY, 209 210 /** Class instance creation expressions, of type NewClass. 211 */ 212 NEWCLASS, 213 214 /** Array creation expressions, of type NewArray. 215 */ 216 NEWARRAY, 217 218 /** Lambda expression, of type Lambda. 219 */ 220 LAMBDA, 221 222 /** Parenthesized subexpressions, of type Parens. 223 */ 224 PARENS, 225 226 /** Assignment expressions, of type Assign. 227 */ 228 ASSIGN, 229 230 /** Type cast expressions, of type TypeCast. 231 */ 232 TYPECAST, 233 234 /** Type test expressions, of type TypeTest. 235 */ 236 TYPETEST, 237 238 /** Indexed array expressions, of type Indexed. 239 */ 240 INDEXED, 241 242 /** Selections, of type Select. 243 */ 244 SELECT, 245 246 /** Member references, of type Reference. 247 */ 248 REFERENCE, 249 250 /** Simple identifiers, of type Ident. 251 */ 252 IDENT, 253 254 /** Literals, of type Literal. 255 */ 256 LITERAL, 257 258 /** Basic type identifiers, of type TypeIdent. 259 */ 260 TYPEIDENT, 261 262 /** Array types, of type TypeArray. 263 */ 264 TYPEARRAY, 265 266 /** Parameterized types, of type TypeApply. 267 */ 268 TYPEAPPLY, 269 270 /** Union types, of type TypeUnion. 271 */ 272 TYPEUNION, 273 274 /** Intersection types, of type TypeIntersection. 275 */ 276 TYPEINTERSECTION, 277 278 /** Formal type parameters, of type TypeParameter. 279 */ 280 TYPEPARAMETER, 281 282 /** Type argument. 283 */ 284 WILDCARD, 285 286 /** Bound kind: extends, super, exact, or unbound 287 */ 288 TYPEBOUNDKIND, 289 290 /** metadata: Annotation. 291 */ 292 ANNOTATION, 293 294 /** metadata: Type annotation. 295 */ 296 TYPE_ANNOTATION, 297 298 /** metadata: Modifiers 299 */ 300 MODIFIERS, 301 302 /** An annotated type tree. 303 */ 304 ANNOTATED_TYPE, 305 306 /** Error trees, of type Erroneous. 307 */ 308 ERRONEOUS, 309 310 /** Unary operators, of type Unary. 311 */ 312 POS, // + 313 NEG, // - 314 NOT, // ! 315 COMPL, // ~ 316 PREINC, // ++ _ 317 PREDEC, // -- _ 318 POSTINC, // _ ++ 319 POSTDEC, // _ -- 320 321 /** unary operator for null reference checks, only used internally. 322 */ 323 NULLCHK, 324 325 /** Binary operators, of type Binary. 326 */ 327 OR, // || 328 AND, // && 329 BITOR, // | 330 BITXOR, // ^ 331 BITAND, // & 332 EQ, // == 333 NE, // != 334 LT, // < 335 GT, // > 336 LE, // <= 337 GE, // >= 338 SL, // << 339 SR, // >> 340 USR, // >>> 341 PLUS, // + 342 MINUS, // - 343 MUL, // * 344 DIV, // / 345 MOD, // % 346 347 /** Assignment operators, of type Assignop. 348 */ 349 BITOR_ASG(BITOR), // |= 350 BITXOR_ASG(BITXOR), // ^= 351 BITAND_ASG(BITAND), // &= 352 353 SL_ASG(SL), // <<= 354 SR_ASG(SR), // >>= 355 USR_ASG(USR), // >>>= 356 PLUS_ASG(PLUS), // += 357 MINUS_ASG(MINUS), // -= 358 MUL_ASG(MUL), // *= 359 DIV_ASG(DIV), // /= 360 MOD_ASG(MOD), // %= 361 362 MODULEDEF, 363 EXPORTS, 364 OPENS, 365 PROVIDES, 366 REQUIRES, 367 USES, 368 369 /** A synthetic let expression, of type LetExpr. 370 */ 371 LETEXPR; // ala scheme 372 373 private final Tag noAssignTag; 374 375 private static final int numberOfOperators = MOD.ordinal() - POS.ordinal() + 1; 376 377 private Tag(Tag noAssignTag) { 378 this.noAssignTag = noAssignTag; 379 } 380 381 private Tag() { 382 this(null); 383 } 384 385 public static int getNumberOfOperators() { 386 return numberOfOperators; 387 } 388 389 public Tag noAssignOp() { 390 if (noAssignTag != null) 391 return noAssignTag; 392 throw new AssertionError("noAssignOp() method is not available for non assignment tags"); 393 } 394 395 public boolean isPostUnaryOp() { 396 return (this == POSTINC || this == POSTDEC); 397 } 398 399 public boolean isIncOrDecUnaryOp() { 400 return (this == PREINC || this == PREDEC || this == POSTINC || this == POSTDEC); 401 } 402 403 public boolean isAssignop() { 404 return noAssignTag != null; 405 } 406 407 public int operatorIndex() { 408 return (this.ordinal() - POS.ordinal()); 409 } 410 } 411 412 /* The (encoded) position in the source file. @see util.Position. 413 */ 414 public int pos; 415 416 /* The type of this node. 417 */ 418 public Type type; 419 420 /* The tag of this node -- one of the constants declared above. 421 */ 422 public abstract Tag getTag(); 423 424 /* Returns true if the tag of this node is equals to tag. 425 */ 426 public boolean hasTag(Tag tag) { 427 return tag == getTag(); 428 } 429 430 /** Convert a tree to a pretty-printed string. */ 431 @Override 432 public String toString() { 433 StringWriter s = new StringWriter(); 434 try { 435 new Pretty(s, false).printExpr(this); 436 } 437 catch (IOException e) { 438 // should never happen, because StringWriter is defined 439 // never to throw any IOExceptions 440 throw new AssertionError(e); 441 } 442 return s.toString(); 443 } 444 445 /** Set position field and return this tree. 446 */ 447 public JCTree setPos(int pos) { 448 this.pos = pos; 449 return this; 450 } 451 452 /** Set type field and return this tree. 453 */ 454 public JCTree setType(Type type) { 455 this.type = type; 456 return this; 457 } 458 459 /** Visit this tree with a given visitor. 460 */ 461 public abstract void accept(Visitor v); 462 463 @DefinedBy(Api.COMPILER_TREE) 464 public abstract <R,D> R accept(TreeVisitor<R,D> v, D d); 465 466 /** Return a shallow copy of this tree. 467 */ 468 @Override 469 public Object clone() { 470 try { 471 return super.clone(); 472 } catch(CloneNotSupportedException e) { 473 throw new RuntimeException(e); 474 } 475 } 476 477 /** Get a default position for this tree node. 478 */ 479 public DiagnosticPosition pos() { 480 return this; 481 } 482 483 // for default DiagnosticPosition 484 public JCTree getTree() { 485 return this; 486 } 487 488 // for default DiagnosticPosition 489 public int getStartPosition() { 490 return TreeInfo.getStartPos(this); 491 } 492 493 // for default DiagnosticPosition 494 public int getPreferredPosition() { 495 return pos; 496 } 497 498 // for default DiagnosticPosition 499 public int getEndPosition(EndPosTable endPosTable) { 500 return TreeInfo.getEndPos(this, endPosTable); 501 } 502 503 /** 504 * Everything in one source file is kept in a {@linkplain JCCompilationUnit} structure. 505 */ 506 public static class JCCompilationUnit extends JCTree implements CompilationUnitTree { 507 /** All definitions in this file (ClassDef, Import, and Skip) */ 508 public List<JCTree> defs; 509 /** The source file name. */ 510 public JavaFileObject sourcefile; 511 /** The module to which this compilation unit belongs. */ 512 public ModuleSymbol modle; 513 /** The location in which this compilation unit was found. */ 514 public Location locn; 515 /** The package to which this compilation unit belongs. */ 516 public PackageSymbol packge; 517 /** A scope containing top level classes. */ 518 public WriteableScope toplevelScope; 519 /** A scope for all named imports. */ 520 public NamedImportScope namedImportScope; 521 /** A scope for all import-on-demands. */ 522 public StarImportScope starImportScope; 523 /** Line starting positions, defined only if option -g is set. */ 524 public Position.LineMap lineMap = null; 525 /** A table that stores all documentation comments indexed by the tree 526 * nodes they refer to. defined only if option -s is set. */ 527 public DocCommentTable docComments = null; 528 /* An object encapsulating ending positions of source ranges indexed by 529 * the tree nodes they belong to. Defined only if option -Xjcov is set. */ 530 public EndPosTable endPositions = null; 531 protected JCCompilationUnit(List<JCTree> defs) { 532 this.defs = defs; 533 } 534 @Override 535 public void accept(Visitor v) { v.visitTopLevel(this); } 536 537 @DefinedBy(Api.COMPILER_TREE) 538 public Kind getKind() { return Kind.COMPILATION_UNIT; } 539 540 public JCModuleDecl getModuleDecl() { 541 for (JCTree tree : defs) { 542 if (tree.hasTag(MODULEDEF)) { 543 return (JCModuleDecl) tree; 544 } 545 } 546 547 return null; 548 } 549 550 @DefinedBy(Api.COMPILER_TREE) 551 public JCPackageDecl getPackage() { 552 // PackageDecl must be the first entry if it exists 553 if (!defs.isEmpty() && defs.head.hasTag(PACKAGEDEF)) 554 return (JCPackageDecl)defs.head; 555 return null; 556 } 557 @DefinedBy(Api.COMPILER_TREE) 558 public List<JCAnnotation> getPackageAnnotations() { 559 JCPackageDecl pd = getPackage(); 560 return pd != null ? pd.getAnnotations() : List.nil(); 561 } 562 @DefinedBy(Api.COMPILER_TREE) 563 public ExpressionTree getPackageName() { 564 JCPackageDecl pd = getPackage(); 565 return pd != null ? pd.getPackageName() : null; 566 } 567 568 @DefinedBy(Api.COMPILER_TREE) 569 public List<JCImport> getImports() { 570 ListBuffer<JCImport> imports = new ListBuffer<>(); 571 for (JCTree tree : defs) { 572 if (tree.hasTag(IMPORT)) 573 imports.append((JCImport)tree); 574 else if (!tree.hasTag(PACKAGEDEF) && !tree.hasTag(SKIP)) 575 break; 576 } 577 return imports.toList(); 578 } 579 @DefinedBy(Api.COMPILER_TREE) 580 public JavaFileObject getSourceFile() { 581 return sourcefile; 582 } 583 @DefinedBy(Api.COMPILER_TREE) 584 public Position.LineMap getLineMap() { 585 return lineMap; 586 } 587 @DefinedBy(Api.COMPILER_TREE) 588 public List<JCTree> getTypeDecls() { 589 List<JCTree> typeDefs; 590 for (typeDefs = defs; !typeDefs.isEmpty(); typeDefs = typeDefs.tail) 591 if (!typeDefs.head.hasTag(PACKAGEDEF) && !typeDefs.head.hasTag(IMPORT)) 592 break; 593 return typeDefs; 594 } 595 @Override @DefinedBy(Api.COMPILER_TREE) 596 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 597 return v.visitCompilationUnit(this, d); 598 } 599 600 @Override 601 public Tag getTag() { 602 return TOPLEVEL; 603 } 604 } 605 606 /** 607 * Package definition. 608 */ 609 public static class JCPackageDecl extends JCTree implements PackageTree { 610 public List<JCAnnotation> annotations; 611 /** The tree representing the package clause. */ 612 public JCExpression pid; 613 public PackageSymbol packge; 614 public JCPackageDecl(List<JCAnnotation> annotations, JCExpression pid) { 615 this.annotations = annotations; 616 this.pid = pid; 617 } 618 @Override 619 public void accept(Visitor v) { v.visitPackageDef(this); } 620 @DefinedBy(Api.COMPILER_TREE) 621 public Kind getKind() { 622 return Kind.PACKAGE; 623 } 624 @DefinedBy(Api.COMPILER_TREE) 625 public List<JCAnnotation> getAnnotations() { 626 return annotations; 627 } 628 @DefinedBy(Api.COMPILER_TREE) 629 public JCExpression getPackageName() { 630 return pid; 631 } 632 @Override @DefinedBy(Api.COMPILER_TREE) 633 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 634 return v.visitPackage(this, d); 635 } 636 @Override 637 public Tag getTag() { 638 return PACKAGEDEF; 639 } 640 } 641 642 /** 643 * An import clause. 644 */ 645 public static class JCImport extends JCTree implements ImportTree { 646 public boolean staticImport; 647 /** The imported class(es). */ 648 public JCTree qualid; 649 public com.sun.tools.javac.code.Scope importScope; 650 protected JCImport(JCTree qualid, boolean importStatic) { 651 this.qualid = qualid; 652 this.staticImport = importStatic; 653 } 654 @Override 655 public void accept(Visitor v) { v.visitImport(this); } 656 657 @DefinedBy(Api.COMPILER_TREE) 658 public boolean isStatic() { return staticImport; } 659 @DefinedBy(Api.COMPILER_TREE) 660 public JCTree getQualifiedIdentifier() { return qualid; } 661 662 @DefinedBy(Api.COMPILER_TREE) 663 public Kind getKind() { return Kind.IMPORT; } 664 @Override @DefinedBy(Api.COMPILER_TREE) 665 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 666 return v.visitImport(this, d); 667 } 668 669 @Override 670 public Tag getTag() { 671 return IMPORT; 672 } 673 } 674 675 public static abstract class JCStatement extends JCTree implements StatementTree { 676 @Override 677 public JCStatement setType(Type type) { 678 super.setType(type); 679 return this; 680 } 681 @Override 682 public JCStatement setPos(int pos) { 683 super.setPos(pos); 684 return this; 685 } 686 } 687 688 public static abstract class JCExpression extends JCTree implements ExpressionTree { 689 @Override 690 public JCExpression setType(Type type) { 691 super.setType(type); 692 return this; 693 } 694 @Override 695 public JCExpression setPos(int pos) { 696 super.setPos(pos); 697 return this; 698 } 699 700 public boolean isPoly() { return false; } 701 public boolean isStandalone() { return true; } 702 } 703 704 /** 705 * Common supertype for all poly expression trees (lambda, method references, 706 * conditionals, method and constructor calls) 707 */ 708 public static abstract class JCPolyExpression extends JCExpression { 709 710 /** 711 * A poly expression can only be truly 'poly' in certain contexts 712 */ 713 public enum PolyKind { 714 /** poly expression to be treated as a standalone expression */ 715 STANDALONE, 716 /** true poly expression */ 717 POLY 718 } 719 720 /** is this poly expression a 'true' poly expression? */ 721 public PolyKind polyKind; 722 723 @Override public boolean isPoly() { return polyKind == PolyKind.POLY; } 724 @Override public boolean isStandalone() { return polyKind == PolyKind.STANDALONE; } 725 } 726 727 /** 728 * Common supertype for all functional expression trees (lambda and method references) 729 */ 730 public static abstract class JCFunctionalExpression extends JCPolyExpression { 731 732 public JCFunctionalExpression() { 733 //a functional expression is always a 'true' poly 734 polyKind = PolyKind.POLY; 735 } 736 737 /** list of target types inferred for this functional expression. */ 738 public Type target; 739 740 public Type getDescriptorType(Types types) { 741 return target != null ? types.findDescriptorType(target) : types.createErrorType(null); 742 } 743 } 744 745 /** 746 * A class definition. 747 */ 748 public static class JCClassDecl extends JCStatement implements ClassTree { 749 /** the modifiers */ 750 public JCModifiers mods; 751 /** the name of the class */ 752 public Name name; 753 /** formal class parameters */ 754 public List<JCTypeParameter> typarams; 755 /** the classes this class extends */ 756 public JCExpression extending; 757 /** the interfaces implemented by this class */ 758 public List<JCExpression> implementing; 759 /** all variables and methods defined in this class */ 760 public List<JCTree> defs; 761 /** the symbol */ 762 public ClassSymbol sym; 763 protected JCClassDecl(JCModifiers mods, 764 Name name, 765 List<JCTypeParameter> typarams, 766 JCExpression extending, 767 List<JCExpression> implementing, 768 List<JCTree> defs, 769 ClassSymbol sym) 770 { 771 this.mods = mods; 772 this.name = name; 773 this.typarams = typarams; 774 this.extending = extending; 775 this.implementing = implementing; 776 this.defs = defs; 777 this.sym = sym; 778 } 779 @Override 780 public void accept(Visitor v) { v.visitClassDef(this); } 781 782 @DefinedBy(Api.COMPILER_TREE) 783 public Kind getKind() { 784 if ((mods.flags & Flags.ANNOTATION) != 0) 785 return Kind.ANNOTATION_TYPE; 786 else if ((mods.flags & Flags.INTERFACE) != 0) 787 return Kind.INTERFACE; 788 else if ((mods.flags & Flags.ENUM) != 0) 789 return Kind.ENUM; 790 else 791 return Kind.CLASS; 792 } 793 794 @DefinedBy(Api.COMPILER_TREE) 795 public JCModifiers getModifiers() { return mods; } 796 @DefinedBy(Api.COMPILER_TREE) 797 public Name getSimpleName() { return name; } 798 @DefinedBy(Api.COMPILER_TREE) 799 public List<JCTypeParameter> getTypeParameters() { 800 return typarams; 801 } 802 @DefinedBy(Api.COMPILER_TREE) 803 public JCExpression getExtendsClause() { return extending; } 804 @DefinedBy(Api.COMPILER_TREE) 805 public List<JCExpression> getImplementsClause() { 806 return implementing; 807 } 808 @DefinedBy(Api.COMPILER_TREE) 809 public List<JCTree> getMembers() { 810 return defs; 811 } 812 @Override @DefinedBy(Api.COMPILER_TREE) 813 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 814 return v.visitClass(this, d); 815 } 816 817 @Override 818 public Tag getTag() { 819 return CLASSDEF; 820 } 821 } 822 823 /** 824 * A method definition. 825 */ 826 public static class JCMethodDecl extends JCTree implements MethodTree { 827 /** method modifiers */ 828 public JCModifiers mods; 829 /** method name */ 830 public Name name; 831 /** type of method return value */ 832 public JCExpression restype; 833 /** type parameters */ 834 public List<JCTypeParameter> typarams; 835 /** receiver parameter */ 836 public JCVariableDecl recvparam; 837 /** value parameters */ 838 public List<JCVariableDecl> params; 839 /** exceptions thrown by this method */ 840 public List<JCExpression> thrown; 841 /** statements in the method */ 842 public JCBlock body; 843 /** default value, for annotation types */ 844 public JCExpression defaultValue; 845 /** method symbol */ 846 public MethodSymbol sym; 847 protected JCMethodDecl(JCModifiers mods, 848 Name name, 849 JCExpression restype, 850 List<JCTypeParameter> typarams, 851 JCVariableDecl recvparam, 852 List<JCVariableDecl> params, 853 List<JCExpression> thrown, 854 JCBlock body, 855 JCExpression defaultValue, 856 MethodSymbol sym) 857 { 858 this.mods = mods; 859 this.name = name; 860 this.restype = restype; 861 this.typarams = typarams; 862 this.params = params; 863 this.recvparam = recvparam; 864 // TODO: do something special if the given type is null? 865 // receiver != null ? receiver : List.<JCTypeAnnotation>nil()); 866 this.thrown = thrown; 867 this.body = body; 868 this.defaultValue = defaultValue; 869 this.sym = sym; 870 } 871 @Override 872 public void accept(Visitor v) { v.visitMethodDef(this); } 873 874 @DefinedBy(Api.COMPILER_TREE) 875 public Kind getKind() { return Kind.METHOD; } 876 @DefinedBy(Api.COMPILER_TREE) 877 public JCModifiers getModifiers() { return mods; } 878 @DefinedBy(Api.COMPILER_TREE) 879 public Name getName() { return name; } 880 @DefinedBy(Api.COMPILER_TREE) 881 public JCTree getReturnType() { return restype; } 882 @DefinedBy(Api.COMPILER_TREE) 883 public List<JCTypeParameter> getTypeParameters() { 884 return typarams; 885 } 886 @DefinedBy(Api.COMPILER_TREE) 887 public List<JCVariableDecl> getParameters() { 888 return params; 889 } 890 @DefinedBy(Api.COMPILER_TREE) 891 public JCVariableDecl getReceiverParameter() { return recvparam; } 892 @DefinedBy(Api.COMPILER_TREE) 893 public List<JCExpression> getThrows() { 894 return thrown; 895 } 896 @DefinedBy(Api.COMPILER_TREE) 897 public JCBlock getBody() { return body; } 898 @DefinedBy(Api.COMPILER_TREE) 899 public JCTree getDefaultValue() { // for annotation types 900 return defaultValue; 901 } 902 @Override @DefinedBy(Api.COMPILER_TREE) 903 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 904 return v.visitMethod(this, d); 905 } 906 907 @Override 908 public Tag getTag() { 909 return METHODDEF; 910 } 911 } 912 913 /** 914 * A variable definition. 915 */ 916 public static class JCVariableDecl extends JCStatement implements VariableTree { 917 /** variable modifiers */ 918 public JCModifiers mods; 919 /** variable name */ 920 public Name name; 921 /** variable name expression */ 922 public JCExpression nameexpr; 923 /** type of the variable */ 924 public JCExpression vartype; 925 /** variable's initial value */ 926 public JCExpression init; 927 /** symbol */ 928 public VarSymbol sym; 929 /** explicit start pos */ 930 public int startPos = Position.NOPOS; 931 932 protected JCVariableDecl(JCModifiers mods, 933 Name name, 934 JCExpression vartype, 935 JCExpression init, 936 VarSymbol sym) { 937 this.mods = mods; 938 this.name = name; 939 this.vartype = vartype; 940 this.init = init; 941 this.sym = sym; 942 } 943 944 protected JCVariableDecl(JCModifiers mods, 945 JCExpression nameexpr, 946 JCExpression vartype) { 947 this(mods, null, vartype, null, null); 948 this.nameexpr = nameexpr; 949 if (nameexpr.hasTag(Tag.IDENT)) { 950 this.name = ((JCIdent)nameexpr).name; 951 } else { 952 // Only other option is qualified name x.y.this; 953 this.name = ((JCFieldAccess)nameexpr).name; 954 } 955 } 956 957 public boolean isImplicitlyTyped() { 958 return vartype == null; 959 } 960 961 @Override 962 public void accept(Visitor v) { v.visitVarDef(this); } 963 964 @DefinedBy(Api.COMPILER_TREE) 965 public Kind getKind() { return Kind.VARIABLE; } 966 @DefinedBy(Api.COMPILER_TREE) 967 public JCModifiers getModifiers() { return mods; } 968 @DefinedBy(Api.COMPILER_TREE) 969 public Name getName() { return name; } 970 @DefinedBy(Api.COMPILER_TREE) 971 public JCExpression getNameExpression() { return nameexpr; } 972 @DefinedBy(Api.COMPILER_TREE) 973 public JCTree getType() { return vartype; } 974 @DefinedBy(Api.COMPILER_TREE) 975 public JCExpression getInitializer() { 976 return init; 977 } 978 @Override @DefinedBy(Api.COMPILER_TREE) 979 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 980 return v.visitVariable(this, d); 981 } 982 983 @Override 984 public Tag getTag() { 985 return VARDEF; 986 } 987 } 988 989 /** 990 * A no-op statement ";". 991 */ 992 public static class JCSkip extends JCStatement implements EmptyStatementTree { 993 protected JCSkip() { 994 } 995 @Override 996 public void accept(Visitor v) { v.visitSkip(this); } 997 998 @DefinedBy(Api.COMPILER_TREE) 999 public Kind getKind() { return Kind.EMPTY_STATEMENT; } 1000 @Override @DefinedBy(Api.COMPILER_TREE) 1001 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1002 return v.visitEmptyStatement(this, d); 1003 } 1004 1005 @Override 1006 public Tag getTag() { 1007 return SKIP; 1008 } 1009 } 1010 1011 /** 1012 * A statement block. 1013 */ 1014 public static class JCBlock extends JCStatement implements BlockTree { 1015 /** flags */ 1016 public long flags; 1017 /** statements */ 1018 public List<JCStatement> stats; 1019 /** Position of closing brace, optional. */ 1020 public int endpos = Position.NOPOS; 1021 protected JCBlock(long flags, List<JCStatement> stats) { 1022 this.stats = stats; 1023 this.flags = flags; 1024 } 1025 @Override 1026 public void accept(Visitor v) { v.visitBlock(this); } 1027 1028 @DefinedBy(Api.COMPILER_TREE) 1029 public Kind getKind() { return Kind.BLOCK; } 1030 @DefinedBy(Api.COMPILER_TREE) 1031 public List<JCStatement> getStatements() { 1032 return stats; 1033 } 1034 @DefinedBy(Api.COMPILER_TREE) 1035 public boolean isStatic() { return (flags & Flags.STATIC) != 0; } 1036 @Override @DefinedBy(Api.COMPILER_TREE) 1037 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1038 return v.visitBlock(this, d); 1039 } 1040 1041 @Override 1042 public Tag getTag() { 1043 return BLOCK; 1044 } 1045 } 1046 1047 /** 1048 * A do loop 1049 */ 1050 public static class JCDoWhileLoop extends JCStatement implements DoWhileLoopTree { 1051 public JCStatement body; 1052 public JCExpression cond; 1053 protected JCDoWhileLoop(JCStatement body, JCExpression cond) { 1054 this.body = body; 1055 this.cond = cond; 1056 } 1057 @Override 1058 public void accept(Visitor v) { v.visitDoLoop(this); } 1059 1060 @DefinedBy(Api.COMPILER_TREE) 1061 public Kind getKind() { return Kind.DO_WHILE_LOOP; } 1062 @DefinedBy(Api.COMPILER_TREE) 1063 public JCExpression getCondition() { return cond; } 1064 @DefinedBy(Api.COMPILER_TREE) 1065 public JCStatement getStatement() { return body; } 1066 @Override @DefinedBy(Api.COMPILER_TREE) 1067 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1068 return v.visitDoWhileLoop(this, d); 1069 } 1070 1071 @Override 1072 public Tag getTag() { 1073 return DOLOOP; 1074 } 1075 } 1076 1077 /** 1078 * A while loop 1079 */ 1080 public static class JCWhileLoop extends JCStatement implements WhileLoopTree { 1081 public JCExpression cond; 1082 public JCStatement body; 1083 protected JCWhileLoop(JCExpression cond, JCStatement body) { 1084 this.cond = cond; 1085 this.body = body; 1086 } 1087 @Override 1088 public void accept(Visitor v) { v.visitWhileLoop(this); } 1089 1090 @DefinedBy(Api.COMPILER_TREE) 1091 public Kind getKind() { return Kind.WHILE_LOOP; } 1092 @DefinedBy(Api.COMPILER_TREE) 1093 public JCExpression getCondition() { return cond; } 1094 @DefinedBy(Api.COMPILER_TREE) 1095 public JCStatement getStatement() { return body; } 1096 @Override @DefinedBy(Api.COMPILER_TREE) 1097 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1098 return v.visitWhileLoop(this, d); 1099 } 1100 1101 @Override 1102 public Tag getTag() { 1103 return WHILELOOP; 1104 } 1105 } 1106 1107 /** 1108 * A for loop. 1109 */ 1110 public static class JCForLoop extends JCStatement implements ForLoopTree { 1111 public List<JCStatement> init; 1112 public JCExpression cond; 1113 public List<JCExpressionStatement> step; 1114 public JCStatement body; 1115 protected JCForLoop(List<JCStatement> init, 1116 JCExpression cond, 1117 List<JCExpressionStatement> update, 1118 JCStatement body) 1119 { 1120 this.init = init; 1121 this.cond = cond; 1122 this.step = update; 1123 this.body = body; 1124 } 1125 @Override 1126 public void accept(Visitor v) { v.visitForLoop(this); } 1127 1128 @DefinedBy(Api.COMPILER_TREE) 1129 public Kind getKind() { return Kind.FOR_LOOP; } 1130 @DefinedBy(Api.COMPILER_TREE) 1131 public JCExpression getCondition() { return cond; } 1132 @DefinedBy(Api.COMPILER_TREE) 1133 public JCStatement getStatement() { return body; } 1134 @DefinedBy(Api.COMPILER_TREE) 1135 public List<JCStatement> getInitializer() { 1136 return init; 1137 } 1138 @DefinedBy(Api.COMPILER_TREE) 1139 public List<JCExpressionStatement> getUpdate() { 1140 return step; 1141 } 1142 @Override @DefinedBy(Api.COMPILER_TREE) 1143 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1144 return v.visitForLoop(this, d); 1145 } 1146 1147 @Override 1148 public Tag getTag() { 1149 return FORLOOP; 1150 } 1151 } 1152 1153 /** 1154 * The enhanced for loop. 1155 */ 1156 public static class JCEnhancedForLoop extends JCStatement implements EnhancedForLoopTree { 1157 public JCVariableDecl var; 1158 public JCExpression expr; 1159 public JCStatement body; 1160 protected JCEnhancedForLoop(JCVariableDecl var, JCExpression expr, JCStatement body) { 1161 this.var = var; 1162 this.expr = expr; 1163 this.body = body; 1164 } 1165 @Override 1166 public void accept(Visitor v) { v.visitForeachLoop(this); } 1167 1168 @DefinedBy(Api.COMPILER_TREE) 1169 public Kind getKind() { return Kind.ENHANCED_FOR_LOOP; } 1170 @DefinedBy(Api.COMPILER_TREE) 1171 public JCVariableDecl getVariable() { return var; } 1172 @DefinedBy(Api.COMPILER_TREE) 1173 public JCExpression getExpression() { return expr; } 1174 @DefinedBy(Api.COMPILER_TREE) 1175 public JCStatement getStatement() { return body; } 1176 @Override @DefinedBy(Api.COMPILER_TREE) 1177 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1178 return v.visitEnhancedForLoop(this, d); 1179 } 1180 @Override 1181 public Tag getTag() { 1182 return FOREACHLOOP; 1183 } 1184 } 1185 1186 /** 1187 * A labelled expression or statement. 1188 */ 1189 public static class JCLabeledStatement extends JCStatement implements LabeledStatementTree { 1190 public Name label; 1191 public JCStatement body; 1192 protected JCLabeledStatement(Name label, JCStatement body) { 1193 this.label = label; 1194 this.body = body; 1195 } 1196 @Override 1197 public void accept(Visitor v) { v.visitLabelled(this); } 1198 @DefinedBy(Api.COMPILER_TREE) 1199 public Kind getKind() { return Kind.LABELED_STATEMENT; } 1200 @DefinedBy(Api.COMPILER_TREE) 1201 public Name getLabel() { return label; } 1202 @DefinedBy(Api.COMPILER_TREE) 1203 public JCStatement getStatement() { return body; } 1204 @Override @DefinedBy(Api.COMPILER_TREE) 1205 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1206 return v.visitLabeledStatement(this, d); 1207 } 1208 @Override 1209 public Tag getTag() { 1210 return LABELLED; 1211 } 1212 } 1213 1214 /** 1215 * A "switch ( ) { }" construction. 1216 */ 1217 public static class JCSwitch extends JCStatement implements SwitchTree { 1218 public JCExpression selector; 1219 public List<JCCase> cases; 1220 protected JCSwitch(JCExpression selector, List<JCCase> cases) { 1221 this.selector = selector; 1222 this.cases = cases; 1223 } 1224 @Override 1225 public void accept(Visitor v) { v.visitSwitch(this); } 1226 1227 @DefinedBy(Api.COMPILER_TREE) 1228 public Kind getKind() { return Kind.SWITCH; } 1229 @DefinedBy(Api.COMPILER_TREE) 1230 public JCExpression getExpression() { return selector; } 1231 @DefinedBy(Api.COMPILER_TREE) 1232 public List<JCCase> getCases() { return cases; } 1233 @Override @DefinedBy(Api.COMPILER_TREE) 1234 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1235 return v.visitSwitch(this, d); 1236 } 1237 @Override 1238 public Tag getTag() { 1239 return SWITCH; 1240 } 1241 } 1242 1243 /** 1244 * A "case :" of a switch. 1245 */ 1246 public static class JCCase extends JCStatement implements CaseTree { 1247 //as CaseKind is deprecated for removal (as it is part of a preview feature), 1248 //using indirection through these fields to avoid unnecessary @SuppressWarnings: 1249 @SuppressWarnings("removal") 1250 public static final CaseKind STATEMENT = CaseKind.STATEMENT; 1251 @SuppressWarnings("removal") 1252 public static final CaseKind RULE = CaseKind.RULE; 1253 @SuppressWarnings("removal") 1254 public final CaseKind caseKind; 1255 public List<JCExpression> pats; 1256 public List<JCStatement> stats; 1257 public JCTree body; 1258 public boolean completesNormally; 1259 protected JCCase(@SuppressWarnings("removal") CaseKind caseKind, List<JCExpression> pats, 1260 List<JCStatement> stats, JCTree body) { 1261 Assert.checkNonNull(pats); 1262 Assert.check(pats.isEmpty() || pats.head != null); 1263 this.caseKind = caseKind; 1264 this.pats = pats; 1265 this.stats = stats; 1266 this.body = body; 1267 } 1268 @Override 1269 public void accept(Visitor v) { v.visitCase(this); } 1270 1271 @Override @DefinedBy(Api.COMPILER_TREE) 1272 public Kind getKind() { return Kind.CASE; } 1273 @Override @DefinedBy(Api.COMPILER_TREE) 1274 public JCExpression getExpression() { return pats.head; } 1275 @Override @DefinedBy(Api.COMPILER_TREE) 1276 @SuppressWarnings("removal") 1277 public List<JCExpression> getExpressions() { return pats; } 1278 @Override @DefinedBy(Api.COMPILER_TREE) 1279 @SuppressWarnings("removal") 1280 public List<JCStatement> getStatements() { 1281 return caseKind == CaseKind.STATEMENT ? stats : null; 1282 } 1283 @Override @DefinedBy(Api.COMPILER_TREE) 1284 @SuppressWarnings("removal") 1285 public JCTree getBody() { return body; } 1286 @Override @DefinedBy(Api.COMPILER_TREE) 1287 @SuppressWarnings("removal") 1288 public CaseKind getCaseKind() { 1289 return caseKind; 1290 } 1291 @Override @DefinedBy(Api.COMPILER_TREE) 1292 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1293 return v.visitCase(this, d); 1294 } 1295 @Override 1296 public Tag getTag() { 1297 return CASE; 1298 } 1299 } 1300 1301 /** 1302 * A "switch ( ) { }" construction. 1303 */ 1304 @SuppressWarnings("removal") 1305 public static class JCSwitchExpression extends JCPolyExpression implements SwitchExpressionTree { 1306 public JCExpression selector; 1307 public List<JCCase> cases; 1308 /** Position of closing brace, optional. */ 1309 public int endpos = Position.NOPOS; 1310 protected JCSwitchExpression(JCExpression selector, List<JCCase> cases) { 1311 this.selector = selector; 1312 this.cases = cases; 1313 } 1314 @Override 1315 public void accept(Visitor v) { v.visitSwitchExpression(this); } 1316 1317 @DefinedBy(Api.COMPILER_TREE) 1318 public Kind getKind() { return Kind.SWITCH_EXPRESSION; } 1319 @DefinedBy(Api.COMPILER_TREE) 1320 public JCExpression getExpression() { return selector; } 1321 @DefinedBy(Api.COMPILER_TREE) 1322 public List<JCCase> getCases() { return cases; } 1323 @Override @DefinedBy(Api.COMPILER_TREE) 1324 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1325 return v.visitSwitchExpression(this, d); 1326 } 1327 @Override 1328 public Tag getTag() { 1329 return SWITCH_EXPRESSION; 1330 } 1331 } 1332 1333 /** 1334 * A synchronized block. 1335 */ 1336 public static class JCSynchronized extends JCStatement implements SynchronizedTree { 1337 public JCExpression lock; 1338 public JCBlock body; 1339 protected JCSynchronized(JCExpression lock, JCBlock body) { 1340 this.lock = lock; 1341 this.body = body; 1342 } 1343 @Override 1344 public void accept(Visitor v) { v.visitSynchronized(this); } 1345 1346 @DefinedBy(Api.COMPILER_TREE) 1347 public Kind getKind() { return Kind.SYNCHRONIZED; } 1348 @DefinedBy(Api.COMPILER_TREE) 1349 public JCExpression getExpression() { return lock; } 1350 @DefinedBy(Api.COMPILER_TREE) 1351 public JCBlock getBlock() { return body; } 1352 @Override @DefinedBy(Api.COMPILER_TREE) 1353 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1354 return v.visitSynchronized(this, d); 1355 } 1356 @Override 1357 public Tag getTag() { 1358 return SYNCHRONIZED; 1359 } 1360 } 1361 1362 /** 1363 * A "try { } catch ( ) { } finally { }" block. 1364 */ 1365 public static class JCTry extends JCStatement implements TryTree { 1366 public JCBlock body; 1367 public List<JCCatch> catchers; 1368 public JCBlock finalizer; 1369 public List<JCTree> resources; 1370 public boolean finallyCanCompleteNormally; 1371 protected JCTry(List<JCTree> resources, 1372 JCBlock body, 1373 List<JCCatch> catchers, 1374 JCBlock finalizer) { 1375 this.body = body; 1376 this.catchers = catchers; 1377 this.finalizer = finalizer; 1378 this.resources = resources; 1379 } 1380 @Override 1381 public void accept(Visitor v) { v.visitTry(this); } 1382 1383 @DefinedBy(Api.COMPILER_TREE) 1384 public Kind getKind() { return Kind.TRY; } 1385 @DefinedBy(Api.COMPILER_TREE) 1386 public JCBlock getBlock() { return body; } 1387 @DefinedBy(Api.COMPILER_TREE) 1388 public List<JCCatch> getCatches() { 1389 return catchers; 1390 } 1391 @DefinedBy(Api.COMPILER_TREE) 1392 public JCBlock getFinallyBlock() { return finalizer; } 1393 @Override @DefinedBy(Api.COMPILER_TREE) 1394 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1395 return v.visitTry(this, d); 1396 } 1397 @Override @DefinedBy(Api.COMPILER_TREE) 1398 public List<JCTree> getResources() { 1399 return resources; 1400 } 1401 @Override 1402 public Tag getTag() { 1403 return TRY; 1404 } 1405 } 1406 1407 /** 1408 * A catch block. 1409 */ 1410 public static class JCCatch extends JCTree implements CatchTree { 1411 public JCVariableDecl param; 1412 public JCBlock body; 1413 protected JCCatch(JCVariableDecl param, JCBlock body) { 1414 this.param = param; 1415 this.body = body; 1416 } 1417 @Override 1418 public void accept(Visitor v) { v.visitCatch(this); } 1419 1420 @DefinedBy(Api.COMPILER_TREE) 1421 public Kind getKind() { return Kind.CATCH; } 1422 @DefinedBy(Api.COMPILER_TREE) 1423 public JCVariableDecl getParameter() { return param; } 1424 @DefinedBy(Api.COMPILER_TREE) 1425 public JCBlock getBlock() { return body; } 1426 @Override @DefinedBy(Api.COMPILER_TREE) 1427 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1428 return v.visitCatch(this, d); 1429 } 1430 @Override 1431 public Tag getTag() { 1432 return CATCH; 1433 } 1434 } 1435 1436 /** 1437 * A ( ) ? ( ) : ( ) conditional expression 1438 */ 1439 public static class JCConditional extends JCPolyExpression implements ConditionalExpressionTree { 1440 public JCExpression cond; 1441 public JCExpression truepart; 1442 public JCExpression falsepart; 1443 protected JCConditional(JCExpression cond, 1444 JCExpression truepart, 1445 JCExpression falsepart) 1446 { 1447 this.cond = cond; 1448 this.truepart = truepart; 1449 this.falsepart = falsepart; 1450 } 1451 @Override 1452 public void accept(Visitor v) { v.visitConditional(this); } 1453 1454 @DefinedBy(Api.COMPILER_TREE) 1455 public Kind getKind() { return Kind.CONDITIONAL_EXPRESSION; } 1456 @DefinedBy(Api.COMPILER_TREE) 1457 public JCExpression getCondition() { return cond; } 1458 @DefinedBy(Api.COMPILER_TREE) 1459 public JCExpression getTrueExpression() { return truepart; } 1460 @DefinedBy(Api.COMPILER_TREE) 1461 public JCExpression getFalseExpression() { return falsepart; } 1462 @Override @DefinedBy(Api.COMPILER_TREE) 1463 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1464 return v.visitConditionalExpression(this, d); 1465 } 1466 @Override 1467 public Tag getTag() { 1468 return CONDEXPR; 1469 } 1470 } 1471 1472 /** 1473 * An "if ( ) { } else { }" block 1474 */ 1475 public static class JCIf extends JCStatement implements IfTree { 1476 public JCExpression cond; 1477 public JCStatement thenpart; 1478 public JCStatement elsepart; 1479 protected JCIf(JCExpression cond, 1480 JCStatement thenpart, 1481 JCStatement elsepart) 1482 { 1483 this.cond = cond; 1484 this.thenpart = thenpart; 1485 this.elsepart = elsepart; 1486 } 1487 @Override 1488 public void accept(Visitor v) { v.visitIf(this); } 1489 1490 @DefinedBy(Api.COMPILER_TREE) 1491 public Kind getKind() { return Kind.IF; } 1492 @DefinedBy(Api.COMPILER_TREE) 1493 public JCExpression getCondition() { return cond; } 1494 @DefinedBy(Api.COMPILER_TREE) 1495 public JCStatement getThenStatement() { return thenpart; } 1496 @DefinedBy(Api.COMPILER_TREE) 1497 public JCStatement getElseStatement() { return elsepart; } 1498 @Override @DefinedBy(Api.COMPILER_TREE) 1499 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1500 return v.visitIf(this, d); 1501 } 1502 @Override 1503 public Tag getTag() { 1504 return IF; 1505 } 1506 } 1507 1508 /** 1509 * an expression statement 1510 */ 1511 public static class JCExpressionStatement extends JCStatement implements ExpressionStatementTree { 1512 /** expression structure */ 1513 public JCExpression expr; 1514 protected JCExpressionStatement(JCExpression expr) 1515 { 1516 this.expr = expr; 1517 } 1518 @Override 1519 public void accept(Visitor v) { v.visitExec(this); } 1520 1521 @DefinedBy(Api.COMPILER_TREE) 1522 public Kind getKind() { return Kind.EXPRESSION_STATEMENT; } 1523 @DefinedBy(Api.COMPILER_TREE) 1524 public JCExpression getExpression() { return expr; } 1525 @Override @DefinedBy(Api.COMPILER_TREE) 1526 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1527 return v.visitExpressionStatement(this, d); 1528 } 1529 @Override 1530 public Tag getTag() { 1531 return EXEC; 1532 } 1533 1534 /** Convert a expression-statement tree to a pretty-printed string. */ 1535 @Override 1536 public String toString() { 1537 StringWriter s = new StringWriter(); 1538 try { 1539 new Pretty(s, false).printStat(this); 1540 } 1541 catch (IOException e) { 1542 // should never happen, because StringWriter is defined 1543 // never to throw any IOExceptions 1544 throw new AssertionError(e); 1545 } 1546 return s.toString(); 1547 } 1548 } 1549 1550 /** 1551 * A break from a loop or switch. 1552 */ 1553 public static class JCBreak extends JCStatement implements BreakTree { 1554 public JCExpression value; 1555 public JCTree target; 1556 protected JCBreak(JCExpression value, JCTree target) { 1557 this.value = value; 1558 this.target = target; 1559 } 1560 @Override 1561 public void accept(Visitor v) { v.visitBreak(this); } 1562 public boolean isValueBreak() { 1563 return target != null && target.hasTag(SWITCH_EXPRESSION); 1564 } 1565 1566 @DefinedBy(Api.COMPILER_TREE) 1567 public Kind getKind() { return Kind.BREAK; } 1568 @DefinedBy(Api.COMPILER_TREE) 1569 public Name getLabel() { 1570 return value != null && value.getKind() == Kind.IDENTIFIER ? ((JCIdent) value).getName() : null; 1571 } 1572 @DefinedBy(Api.COMPILER_TREE) 1573 @SuppressWarnings("removal") 1574 public JCExpression getValue() { return value; } 1575 @Override @DefinedBy(Api.COMPILER_TREE) 1576 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1577 return v.visitBreak(this, d); 1578 } 1579 @Override 1580 public Tag getTag() { 1581 return BREAK; 1582 } 1583 } 1584 1585 /** 1586 * A continue of a loop. 1587 */ 1588 public static class JCContinue extends JCStatement implements ContinueTree { 1589 public Name label; 1590 public JCTree target; 1591 protected JCContinue(Name label, JCTree target) { 1592 this.label = label; 1593 this.target = target; 1594 } 1595 @Override 1596 public void accept(Visitor v) { v.visitContinue(this); } 1597 1598 @DefinedBy(Api.COMPILER_TREE) 1599 public Kind getKind() { return Kind.CONTINUE; } 1600 @DefinedBy(Api.COMPILER_TREE) 1601 public Name getLabel() { return label; } 1602 @Override @DefinedBy(Api.COMPILER_TREE) 1603 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1604 return v.visitContinue(this, d); 1605 } 1606 @Override 1607 public Tag getTag() { 1608 return CONTINUE; 1609 } 1610 } 1611 1612 /** 1613 * A return statement. 1614 */ 1615 public static class JCReturn extends JCStatement implements ReturnTree { 1616 public JCExpression expr; 1617 protected JCReturn(JCExpression expr) { 1618 this.expr = expr; 1619 } 1620 @Override 1621 public void accept(Visitor v) { v.visitReturn(this); } 1622 1623 @DefinedBy(Api.COMPILER_TREE) 1624 public Kind getKind() { return Kind.RETURN; } 1625 @DefinedBy(Api.COMPILER_TREE) 1626 public JCExpression getExpression() { return expr; } 1627 @Override @DefinedBy(Api.COMPILER_TREE) 1628 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1629 return v.visitReturn(this, d); 1630 } 1631 @Override 1632 public Tag getTag() { 1633 return RETURN; 1634 } 1635 } 1636 1637 /** 1638 * A throw statement. 1639 */ 1640 public static class JCThrow extends JCStatement implements ThrowTree { 1641 public JCExpression expr; 1642 protected JCThrow(JCExpression expr) { 1643 this.expr = expr; 1644 } 1645 @Override 1646 public void accept(Visitor v) { v.visitThrow(this); } 1647 1648 @DefinedBy(Api.COMPILER_TREE) 1649 public Kind getKind() { return Kind.THROW; } 1650 @DefinedBy(Api.COMPILER_TREE) 1651 public JCExpression getExpression() { return expr; } 1652 @Override @DefinedBy(Api.COMPILER_TREE) 1653 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1654 return v.visitThrow(this, d); 1655 } 1656 @Override 1657 public Tag getTag() { 1658 return THROW; 1659 } 1660 } 1661 1662 /** 1663 * An assert statement. 1664 */ 1665 public static class JCAssert extends JCStatement implements AssertTree { 1666 public JCExpression cond; 1667 public JCExpression detail; 1668 protected JCAssert(JCExpression cond, JCExpression detail) { 1669 this.cond = cond; 1670 this.detail = detail; 1671 } 1672 @Override 1673 public void accept(Visitor v) { v.visitAssert(this); } 1674 1675 @DefinedBy(Api.COMPILER_TREE) 1676 public Kind getKind() { return Kind.ASSERT; } 1677 @DefinedBy(Api.COMPILER_TREE) 1678 public JCExpression getCondition() { return cond; } 1679 @DefinedBy(Api.COMPILER_TREE) 1680 public JCExpression getDetail() { return detail; } 1681 @Override @DefinedBy(Api.COMPILER_TREE) 1682 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1683 return v.visitAssert(this, d); 1684 } 1685 @Override 1686 public Tag getTag() { 1687 return ASSERT; 1688 } 1689 } 1690 1691 /** 1692 * A method invocation 1693 */ 1694 public static class JCMethodInvocation extends JCPolyExpression implements MethodInvocationTree { 1695 public List<JCExpression> typeargs; 1696 public JCExpression meth; 1697 public List<JCExpression> args; 1698 public Type varargsElement; 1699 protected JCMethodInvocation(List<JCExpression> typeargs, 1700 JCExpression meth, 1701 List<JCExpression> args) 1702 { 1703 this.typeargs = (typeargs == null) ? List.nil() 1704 : typeargs; 1705 this.meth = meth; 1706 this.args = args; 1707 } 1708 @Override 1709 public void accept(Visitor v) { v.visitApply(this); } 1710 1711 @DefinedBy(Api.COMPILER_TREE) 1712 public Kind getKind() { return Kind.METHOD_INVOCATION; } 1713 @DefinedBy(Api.COMPILER_TREE) 1714 public List<JCExpression> getTypeArguments() { 1715 return typeargs; 1716 } 1717 @DefinedBy(Api.COMPILER_TREE) 1718 public JCExpression getMethodSelect() { return meth; } 1719 @DefinedBy(Api.COMPILER_TREE) 1720 public List<JCExpression> getArguments() { 1721 return args; 1722 } 1723 @Override @DefinedBy(Api.COMPILER_TREE) 1724 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1725 return v.visitMethodInvocation(this, d); 1726 } 1727 @Override 1728 public JCMethodInvocation setType(Type type) { 1729 super.setType(type); 1730 return this; 1731 } 1732 @Override 1733 public Tag getTag() { 1734 return(APPLY); 1735 } 1736 } 1737 1738 /** 1739 * A new(...) operation. 1740 */ 1741 public static class JCNewClass extends JCPolyExpression implements NewClassTree { 1742 public JCExpression encl; 1743 public List<JCExpression> typeargs; 1744 public JCExpression clazz; 1745 public List<JCExpression> args; 1746 public JCClassDecl def; 1747 public Symbol constructor; 1748 public Type varargsElement; 1749 public Type constructorType; 1750 protected JCNewClass(JCExpression encl, 1751 List<JCExpression> typeargs, 1752 JCExpression clazz, 1753 List<JCExpression> args, 1754 JCClassDecl def) 1755 { 1756 this.encl = encl; 1757 this.typeargs = (typeargs == null) ? List.nil() 1758 : typeargs; 1759 this.clazz = clazz; 1760 this.args = args; 1761 this.def = def; 1762 } 1763 @Override 1764 public void accept(Visitor v) { v.visitNewClass(this); } 1765 1766 @DefinedBy(Api.COMPILER_TREE) 1767 public Kind getKind() { return Kind.NEW_CLASS; } 1768 @DefinedBy(Api.COMPILER_TREE) 1769 public JCExpression getEnclosingExpression() { // expr.new C< ... > ( ... ) 1770 return encl; 1771 } 1772 @DefinedBy(Api.COMPILER_TREE) 1773 public List<JCExpression> getTypeArguments() { 1774 return typeargs; 1775 } 1776 @DefinedBy(Api.COMPILER_TREE) 1777 public JCExpression getIdentifier() { return clazz; } 1778 @DefinedBy(Api.COMPILER_TREE) 1779 public List<JCExpression> getArguments() { 1780 return args; 1781 } 1782 @DefinedBy(Api.COMPILER_TREE) 1783 public JCClassDecl getClassBody() { return def; } 1784 @Override @DefinedBy(Api.COMPILER_TREE) 1785 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1786 return v.visitNewClass(this, d); 1787 } 1788 @Override 1789 public Tag getTag() { 1790 return NEWCLASS; 1791 } 1792 1793 public boolean classDeclRemoved() { 1794 return false; 1795 } 1796 } 1797 1798 /** 1799 * A new[...] operation. 1800 */ 1801 public static class JCNewArray extends JCExpression implements NewArrayTree { 1802 public JCExpression elemtype; 1803 public List<JCExpression> dims; 1804 // type annotations on inner-most component 1805 public List<JCAnnotation> annotations; 1806 // type annotations on dimensions 1807 public List<List<JCAnnotation>> dimAnnotations; 1808 public List<JCExpression> elems; 1809 protected JCNewArray(JCExpression elemtype, 1810 List<JCExpression> dims, 1811 List<JCExpression> elems) 1812 { 1813 this.elemtype = elemtype; 1814 this.dims = dims; 1815 this.annotations = List.nil(); 1816 this.dimAnnotations = List.nil(); 1817 this.elems = elems; 1818 } 1819 @Override 1820 public void accept(Visitor v) { v.visitNewArray(this); } 1821 1822 @DefinedBy(Api.COMPILER_TREE) 1823 public Kind getKind() { return Kind.NEW_ARRAY; } 1824 @DefinedBy(Api.COMPILER_TREE) 1825 public JCExpression getType() { return elemtype; } 1826 @DefinedBy(Api.COMPILER_TREE) 1827 public List<JCExpression> getDimensions() { 1828 return dims; 1829 } 1830 @DefinedBy(Api.COMPILER_TREE) 1831 public List<JCExpression> getInitializers() { 1832 return elems; 1833 } 1834 @Override @DefinedBy(Api.COMPILER_TREE) 1835 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1836 return v.visitNewArray(this, d); 1837 } 1838 @Override 1839 public Tag getTag() { 1840 return NEWARRAY; 1841 } 1842 1843 @Override @DefinedBy(Api.COMPILER_TREE) 1844 public List<JCAnnotation> getAnnotations() { 1845 return annotations; 1846 } 1847 1848 @Override @DefinedBy(Api.COMPILER_TREE) 1849 public List<List<JCAnnotation>> getDimAnnotations() { 1850 return dimAnnotations; 1851 } 1852 } 1853 1854 /** 1855 * A lambda expression. 1856 */ 1857 public static class JCLambda extends JCFunctionalExpression implements LambdaExpressionTree { 1858 1859 public enum ParameterKind { 1860 IMPLICIT, 1861 EXPLICIT 1862 } 1863 1864 public List<JCVariableDecl> params; 1865 public JCTree body; 1866 public boolean canCompleteNormally = true; 1867 public ParameterKind paramKind; 1868 1869 public JCLambda(List<JCVariableDecl> params, 1870 JCTree body) { 1871 this.params = params; 1872 this.body = body; 1873 if (params.isEmpty() || 1874 params.head.vartype != null) { 1875 paramKind = ParameterKind.EXPLICIT; 1876 } else { 1877 paramKind = ParameterKind.IMPLICIT; 1878 } 1879 } 1880 @Override 1881 public Tag getTag() { 1882 return LAMBDA; 1883 } 1884 @Override 1885 public void accept(Visitor v) { 1886 v.visitLambda(this); 1887 } 1888 @Override @DefinedBy(Api.COMPILER_TREE) 1889 public <R, D> R accept(TreeVisitor<R, D> v, D d) { 1890 return v.visitLambdaExpression(this, d); 1891 } 1892 @DefinedBy(Api.COMPILER_TREE) 1893 public Kind getKind() { 1894 return Kind.LAMBDA_EXPRESSION; 1895 } 1896 @DefinedBy(Api.COMPILER_TREE) 1897 public JCTree getBody() { 1898 return body; 1899 } 1900 @DefinedBy(Api.COMPILER_TREE) 1901 public java.util.List<? extends VariableTree> getParameters() { 1902 return params; 1903 } 1904 @Override 1905 public JCLambda setType(Type type) { 1906 super.setType(type); 1907 return this; 1908 } 1909 @Override @DefinedBy(Api.COMPILER_TREE) 1910 public BodyKind getBodyKind() { 1911 return body.hasTag(BLOCK) ? 1912 BodyKind.STATEMENT : 1913 BodyKind.EXPRESSION; 1914 } 1915 } 1916 1917 /** 1918 * A parenthesized subexpression ( ... ) 1919 */ 1920 public static class JCParens extends JCExpression implements ParenthesizedTree { 1921 public JCExpression expr; 1922 protected JCParens(JCExpression expr) { 1923 this.expr = expr; 1924 } 1925 @Override 1926 public void accept(Visitor v) { v.visitParens(this); } 1927 1928 @DefinedBy(Api.COMPILER_TREE) 1929 public Kind getKind() { return Kind.PARENTHESIZED; } 1930 @DefinedBy(Api.COMPILER_TREE) 1931 public JCExpression getExpression() { return expr; } 1932 @Override @DefinedBy(Api.COMPILER_TREE) 1933 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1934 return v.visitParenthesized(this, d); 1935 } 1936 @Override 1937 public Tag getTag() { 1938 return PARENS; 1939 } 1940 } 1941 1942 /** 1943 * A assignment with "=". 1944 */ 1945 public static class JCAssign extends JCExpression implements AssignmentTree { 1946 public JCExpression lhs; 1947 public JCExpression rhs; 1948 protected JCAssign(JCExpression lhs, JCExpression rhs) { 1949 this.lhs = lhs; 1950 this.rhs = rhs; 1951 } 1952 @Override 1953 public void accept(Visitor v) { v.visitAssign(this); } 1954 1955 @DefinedBy(Api.COMPILER_TREE) 1956 public Kind getKind() { return Kind.ASSIGNMENT; } 1957 @DefinedBy(Api.COMPILER_TREE) 1958 public JCExpression getVariable() { return lhs; } 1959 @DefinedBy(Api.COMPILER_TREE) 1960 public JCExpression getExpression() { return rhs; } 1961 @Override @DefinedBy(Api.COMPILER_TREE) 1962 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 1963 return v.visitAssignment(this, d); 1964 } 1965 @Override 1966 public Tag getTag() { 1967 return ASSIGN; 1968 } 1969 } 1970 1971 public static abstract class JCOperatorExpression extends JCExpression { 1972 public enum OperandPos { 1973 LEFT, 1974 RIGHT 1975 } 1976 1977 protected Tag opcode; 1978 public OperatorSymbol operator; 1979 1980 public OperatorSymbol getOperator() { 1981 return operator; 1982 } 1983 1984 @Override 1985 public Tag getTag() { 1986 return opcode; 1987 } 1988 1989 public abstract JCExpression getOperand(OperandPos pos); 1990 } 1991 1992 /** 1993 * An assignment with "+=", "|=" ... 1994 */ 1995 public static class JCAssignOp extends JCOperatorExpression implements CompoundAssignmentTree { 1996 public JCExpression lhs; 1997 public JCExpression rhs; 1998 protected JCAssignOp(Tag opcode, JCTree lhs, JCTree rhs, OperatorSymbol operator) { 1999 this.opcode = opcode; 2000 this.lhs = (JCExpression)lhs; 2001 this.rhs = (JCExpression)rhs; 2002 this.operator = operator; 2003 } 2004 @Override 2005 public void accept(Visitor v) { v.visitAssignop(this); } 2006 2007 @DefinedBy(Api.COMPILER_TREE) 2008 public Kind getKind() { return TreeInfo.tagToKind(getTag()); } 2009 @DefinedBy(Api.COMPILER_TREE) 2010 public JCExpression getVariable() { return lhs; } 2011 @DefinedBy(Api.COMPILER_TREE) 2012 public JCExpression getExpression() { return rhs; } 2013 @Override @DefinedBy(Api.COMPILER_TREE) 2014 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2015 return v.visitCompoundAssignment(this, d); 2016 } 2017 @Override 2018 public JCExpression getOperand(OperandPos pos) { 2019 return pos == OperandPos.LEFT ? lhs : rhs; 2020 } 2021 } 2022 2023 /** 2024 * A unary operation. 2025 */ 2026 public static class JCUnary extends JCOperatorExpression implements UnaryTree { 2027 public JCExpression arg; 2028 protected JCUnary(Tag opcode, JCExpression arg) { 2029 this.opcode = opcode; 2030 this.arg = arg; 2031 } 2032 @Override 2033 public void accept(Visitor v) { v.visitUnary(this); } 2034 2035 @DefinedBy(Api.COMPILER_TREE) 2036 public Kind getKind() { return TreeInfo.tagToKind(getTag()); } 2037 @DefinedBy(Api.COMPILER_TREE) 2038 public JCExpression getExpression() { return arg; } 2039 @Override @DefinedBy(Api.COMPILER_TREE) 2040 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2041 return v.visitUnary(this, d); 2042 } 2043 public void setTag(Tag tag) { 2044 opcode = tag; 2045 } 2046 @Override 2047 public JCExpression getOperand(OperandPos pos) { 2048 return arg; 2049 } 2050 } 2051 2052 /** 2053 * A binary operation. 2054 */ 2055 public static class JCBinary extends JCOperatorExpression implements BinaryTree { 2056 public JCExpression lhs; 2057 public JCExpression rhs; 2058 protected JCBinary(Tag opcode, 2059 JCExpression lhs, 2060 JCExpression rhs, 2061 OperatorSymbol operator) { 2062 this.opcode = opcode; 2063 this.lhs = lhs; 2064 this.rhs = rhs; 2065 this.operator = operator; 2066 } 2067 @Override 2068 public void accept(Visitor v) { v.visitBinary(this); } 2069 2070 @DefinedBy(Api.COMPILER_TREE) 2071 public Kind getKind() { return TreeInfo.tagToKind(getTag()); } 2072 @DefinedBy(Api.COMPILER_TREE) 2073 public JCExpression getLeftOperand() { return lhs; } 2074 @DefinedBy(Api.COMPILER_TREE) 2075 public JCExpression getRightOperand() { return rhs; } 2076 @Override @DefinedBy(Api.COMPILER_TREE) 2077 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2078 return v.visitBinary(this, d); 2079 } 2080 @Override 2081 public JCExpression getOperand(OperandPos pos) { 2082 return pos == OperandPos.LEFT ? lhs : rhs; 2083 } 2084 } 2085 2086 /** 2087 * A type cast. 2088 */ 2089 public static class JCTypeCast extends JCExpression implements TypeCastTree { 2090 public JCTree clazz; 2091 public JCExpression expr; 2092 protected JCTypeCast(JCTree clazz, JCExpression expr) { 2093 this.clazz = clazz; 2094 this.expr = expr; 2095 } 2096 @Override 2097 public void accept(Visitor v) { v.visitTypeCast(this); } 2098 2099 @DefinedBy(Api.COMPILER_TREE) 2100 public Kind getKind() { return Kind.TYPE_CAST; } 2101 @DefinedBy(Api.COMPILER_TREE) 2102 public JCTree getType() { return clazz; } 2103 @DefinedBy(Api.COMPILER_TREE) 2104 public JCExpression getExpression() { return expr; } 2105 @Override @DefinedBy(Api.COMPILER_TREE) 2106 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2107 return v.visitTypeCast(this, d); 2108 } 2109 @Override 2110 public Tag getTag() { 2111 return TYPECAST; 2112 } 2113 } 2114 2115 /** 2116 * A type test. 2117 */ 2118 public static class JCInstanceOf extends JCExpression implements InstanceOfTree { 2119 public JCExpression expr; 2120 public JCTree clazz; 2121 protected JCInstanceOf(JCExpression expr, JCTree clazz) { 2122 this.expr = expr; 2123 this.clazz = clazz; 2124 } 2125 @Override 2126 public void accept(Visitor v) { v.visitTypeTest(this); } 2127 2128 @DefinedBy(Api.COMPILER_TREE) 2129 public Kind getKind() { return Kind.INSTANCE_OF; } 2130 @DefinedBy(Api.COMPILER_TREE) 2131 public JCTree getType() { return clazz; } 2132 @DefinedBy(Api.COMPILER_TREE) 2133 public JCExpression getExpression() { return expr; } 2134 @Override @DefinedBy(Api.COMPILER_TREE) 2135 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2136 return v.visitInstanceOf(this, d); 2137 } 2138 @Override 2139 public Tag getTag() { 2140 return TYPETEST; 2141 } 2142 } 2143 2144 /** 2145 * An array selection 2146 */ 2147 public static class JCArrayAccess extends JCExpression implements ArrayAccessTree { 2148 public JCExpression indexed; 2149 public JCExpression index; 2150 protected JCArrayAccess(JCExpression indexed, JCExpression index) { 2151 this.indexed = indexed; 2152 this.index = index; 2153 } 2154 @Override 2155 public void accept(Visitor v) { v.visitIndexed(this); } 2156 2157 @DefinedBy(Api.COMPILER_TREE) 2158 public Kind getKind() { return Kind.ARRAY_ACCESS; } 2159 @DefinedBy(Api.COMPILER_TREE) 2160 public JCExpression getExpression() { return indexed; } 2161 @DefinedBy(Api.COMPILER_TREE) 2162 public JCExpression getIndex() { return index; } 2163 @Override @DefinedBy(Api.COMPILER_TREE) 2164 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2165 return v.visitArrayAccess(this, d); 2166 } 2167 @Override 2168 public Tag getTag() { 2169 return INDEXED; 2170 } 2171 } 2172 2173 /** 2174 * Selects through packages and classes 2175 */ 2176 public static class JCFieldAccess extends JCExpression implements MemberSelectTree { 2177 /** selected Tree hierarchy */ 2178 public JCExpression selected; 2179 /** name of field to select thru */ 2180 public Name name; 2181 /** symbol of the selected class */ 2182 public Symbol sym; 2183 protected JCFieldAccess(JCExpression selected, Name name, Symbol sym) { 2184 this.selected = selected; 2185 this.name = name; 2186 this.sym = sym; 2187 } 2188 @Override 2189 public void accept(Visitor v) { v.visitSelect(this); } 2190 2191 @DefinedBy(Api.COMPILER_TREE) 2192 public Kind getKind() { return Kind.MEMBER_SELECT; } 2193 @DefinedBy(Api.COMPILER_TREE) 2194 public JCExpression getExpression() { return selected; } 2195 @Override @DefinedBy(Api.COMPILER_TREE) 2196 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2197 return v.visitMemberSelect(this, d); 2198 } 2199 @DefinedBy(Api.COMPILER_TREE) 2200 public Name getIdentifier() { return name; } 2201 @Override 2202 public Tag getTag() { 2203 return SELECT; 2204 } 2205 } 2206 2207 /** 2208 * Selects a member expression. 2209 */ 2210 public static class JCMemberReference extends JCFunctionalExpression implements MemberReferenceTree { 2211 2212 public ReferenceMode mode; 2213 public ReferenceKind kind; 2214 public Name name; 2215 public JCExpression expr; 2216 public List<JCExpression> typeargs; 2217 public Symbol sym; 2218 public Type varargsElement; 2219 public PolyKind refPolyKind; 2220 public boolean ownerAccessible; 2221 private OverloadKind overloadKind; 2222 public Type referentType; 2223 2224 public enum OverloadKind { 2225 OVERLOADED, 2226 UNOVERLOADED, 2227 ERROR 2228 } 2229 2230 /** 2231 * Javac-dependent classification for member references, based 2232 * on relevant properties w.r.t. code-generation 2233 */ 2234 public enum ReferenceKind { 2235 /** super # instMethod */ 2236 SUPER(ReferenceMode.INVOKE, false), 2237 /** Type # instMethod */ 2238 UNBOUND(ReferenceMode.INVOKE, true), 2239 /** Type # staticMethod */ 2240 STATIC(ReferenceMode.INVOKE, false), 2241 /** Expr # instMethod */ 2242 BOUND(ReferenceMode.INVOKE, false), 2243 /** Inner # new */ 2244 IMPLICIT_INNER(ReferenceMode.NEW, false), 2245 /** Toplevel # new */ 2246 TOPLEVEL(ReferenceMode.NEW, false), 2247 /** ArrayType # new */ 2248 ARRAY_CTOR(ReferenceMode.NEW, false); 2249 2250 final ReferenceMode mode; 2251 final boolean unbound; 2252 2253 private ReferenceKind(ReferenceMode mode, boolean unbound) { 2254 this.mode = mode; 2255 this.unbound = unbound; 2256 } 2257 2258 public boolean isUnbound() { 2259 return unbound; 2260 } 2261 } 2262 2263 public JCMemberReference(ReferenceMode mode, Name name, JCExpression expr, List<JCExpression> typeargs) { 2264 this.mode = mode; 2265 this.name = name; 2266 this.expr = expr; 2267 this.typeargs = typeargs; 2268 } 2269 @Override 2270 public void accept(Visitor v) { v.visitReference(this); } 2271 2272 @DefinedBy(Api.COMPILER_TREE) 2273 public Kind getKind() { return Kind.MEMBER_REFERENCE; } 2274 @Override @DefinedBy(Api.COMPILER_TREE) 2275 public ReferenceMode getMode() { return mode; } 2276 @Override @DefinedBy(Api.COMPILER_TREE) 2277 public JCExpression getQualifierExpression() { return expr; } 2278 @Override @DefinedBy(Api.COMPILER_TREE) 2279 public Name getName() { return name; } 2280 @Override @DefinedBy(Api.COMPILER_TREE) 2281 public List<JCExpression> getTypeArguments() { return typeargs; } 2282 2283 @Override @DefinedBy(Api.COMPILER_TREE) 2284 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2285 return v.visitMemberReference(this, d); 2286 } 2287 @Override 2288 public Tag getTag() { 2289 return REFERENCE; 2290 } 2291 public boolean hasKind(ReferenceKind kind) { 2292 return this.kind == kind; 2293 } 2294 2295 /** 2296 * @return the overloadKind 2297 */ 2298 public OverloadKind getOverloadKind() { 2299 return overloadKind; 2300 } 2301 2302 /** 2303 * @param overloadKind the overloadKind to set 2304 */ 2305 public void setOverloadKind(OverloadKind overloadKind) { 2306 this.overloadKind = overloadKind; 2307 } 2308 } 2309 2310 /** 2311 * An identifier 2312 */ 2313 public static class JCIdent extends JCExpression implements IdentifierTree { 2314 /** the name */ 2315 public Name name; 2316 /** the symbol */ 2317 public Symbol sym; 2318 protected JCIdent(Name name, Symbol sym) { 2319 this.name = name; 2320 this.sym = sym; 2321 } 2322 @Override 2323 public void accept(Visitor v) { v.visitIdent(this); } 2324 2325 @DefinedBy(Api.COMPILER_TREE) 2326 public Kind getKind() { return Kind.IDENTIFIER; } 2327 @DefinedBy(Api.COMPILER_TREE) 2328 public Name getName() { return name; } 2329 @Override @DefinedBy(Api.COMPILER_TREE) 2330 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2331 return v.visitIdentifier(this, d); 2332 } 2333 @Override 2334 public Tag getTag() { 2335 return IDENT; 2336 } 2337 } 2338 2339 /** 2340 * A constant value given literally. 2341 */ 2342 public static class JCLiteral extends JCExpression implements LiteralTree { 2343 public TypeTag typetag; 2344 /** value representation */ 2345 public Object value; 2346 protected JCLiteral(TypeTag typetag, Object value) { 2347 this.typetag = typetag; 2348 this.value = value; 2349 } 2350 @Override 2351 public void accept(Visitor v) { v.visitLiteral(this); } 2352 2353 @DefinedBy(Api.COMPILER_TREE) 2354 public Kind getKind() { 2355 return typetag.getKindLiteral(); 2356 } 2357 2358 @DefinedBy(Api.COMPILER_TREE) 2359 public Object getValue() { 2360 switch (typetag) { 2361 case BOOLEAN: 2362 int bi = (Integer) value; 2363 return (bi != 0); 2364 case CHAR: 2365 int ci = (Integer) value; 2366 char c = (char) ci; 2367 if (c != ci) 2368 throw new AssertionError("bad value for char literal"); 2369 return c; 2370 default: 2371 return value; 2372 } 2373 } 2374 @Override @DefinedBy(Api.COMPILER_TREE) 2375 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2376 return v.visitLiteral(this, d); 2377 } 2378 @Override 2379 public JCLiteral setType(Type type) { 2380 super.setType(type); 2381 return this; 2382 } 2383 @Override 2384 public Tag getTag() { 2385 return LITERAL; 2386 } 2387 } 2388 2389 /** 2390 * Identifies a basic type. 2391 * @see TypeTag 2392 */ 2393 public static class JCPrimitiveTypeTree extends JCExpression implements PrimitiveTypeTree { 2394 /** the basic type id */ 2395 public TypeTag typetag; 2396 protected JCPrimitiveTypeTree(TypeTag typetag) { 2397 this.typetag = typetag; 2398 } 2399 @Override 2400 public void accept(Visitor v) { v.visitTypeIdent(this); } 2401 2402 @DefinedBy(Api.COMPILER_TREE) 2403 public Kind getKind() { return Kind.PRIMITIVE_TYPE; } 2404 @DefinedBy(Api.COMPILER_TREE) 2405 public TypeKind getPrimitiveTypeKind() { 2406 return typetag.getPrimitiveTypeKind(); 2407 } 2408 2409 @Override @DefinedBy(Api.COMPILER_TREE) 2410 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2411 return v.visitPrimitiveType(this, d); 2412 } 2413 @Override 2414 public Tag getTag() { 2415 return TYPEIDENT; 2416 } 2417 } 2418 2419 /** 2420 * An array type, A[] 2421 */ 2422 public static class JCArrayTypeTree extends JCExpression implements ArrayTypeTree { 2423 public JCExpression elemtype; 2424 protected JCArrayTypeTree(JCExpression elemtype) { 2425 this.elemtype = elemtype; 2426 } 2427 @Override 2428 public void accept(Visitor v) { v.visitTypeArray(this); } 2429 2430 @DefinedBy(Api.COMPILER_TREE) 2431 public Kind getKind() { return Kind.ARRAY_TYPE; } 2432 @DefinedBy(Api.COMPILER_TREE) 2433 public JCTree getType() { return elemtype; } 2434 @Override @DefinedBy(Api.COMPILER_TREE) 2435 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2436 return v.visitArrayType(this, d); 2437 } 2438 @Override 2439 public Tag getTag() { 2440 return TYPEARRAY; 2441 } 2442 } 2443 2444 /** 2445 * A parameterized type, {@literal T<...>} 2446 */ 2447 public static class JCTypeApply extends JCExpression implements ParameterizedTypeTree { 2448 public JCExpression clazz; 2449 public List<JCExpression> arguments; 2450 protected JCTypeApply(JCExpression clazz, List<JCExpression> arguments) { 2451 this.clazz = clazz; 2452 this.arguments = arguments; 2453 } 2454 @Override 2455 public void accept(Visitor v) { v.visitTypeApply(this); } 2456 2457 @DefinedBy(Api.COMPILER_TREE) 2458 public Kind getKind() { return Kind.PARAMETERIZED_TYPE; } 2459 @DefinedBy(Api.COMPILER_TREE) 2460 public JCTree getType() { return clazz; } 2461 @DefinedBy(Api.COMPILER_TREE) 2462 public List<JCExpression> getTypeArguments() { 2463 return arguments; 2464 } 2465 @Override @DefinedBy(Api.COMPILER_TREE) 2466 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2467 return v.visitParameterizedType(this, d); 2468 } 2469 @Override 2470 public Tag getTag() { 2471 return TYPEAPPLY; 2472 } 2473 } 2474 2475 /** 2476 * A union type, T1 | T2 | ... Tn (used in multicatch statements) 2477 */ 2478 public static class JCTypeUnion extends JCExpression implements UnionTypeTree { 2479 2480 public List<JCExpression> alternatives; 2481 2482 protected JCTypeUnion(List<JCExpression> components) { 2483 this.alternatives = components; 2484 } 2485 @Override 2486 public void accept(Visitor v) { v.visitTypeUnion(this); } 2487 2488 @DefinedBy(Api.COMPILER_TREE) 2489 public Kind getKind() { return Kind.UNION_TYPE; } 2490 2491 @DefinedBy(Api.COMPILER_TREE) 2492 public List<JCExpression> getTypeAlternatives() { 2493 return alternatives; 2494 } 2495 @Override @DefinedBy(Api.COMPILER_TREE) 2496 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2497 return v.visitUnionType(this, d); 2498 } 2499 @Override 2500 public Tag getTag() { 2501 return TYPEUNION; 2502 } 2503 } 2504 2505 /** 2506 * An intersection type, {@code T1 & T2 & ... Tn} (used in cast expressions) 2507 */ 2508 public static class JCTypeIntersection extends JCExpression implements IntersectionTypeTree { 2509 2510 public List<JCExpression> bounds; 2511 2512 protected JCTypeIntersection(List<JCExpression> bounds) { 2513 this.bounds = bounds; 2514 } 2515 @Override 2516 public void accept(Visitor v) { v.visitTypeIntersection(this); } 2517 2518 @DefinedBy(Api.COMPILER_TREE) 2519 public Kind getKind() { return Kind.INTERSECTION_TYPE; } 2520 2521 @DefinedBy(Api.COMPILER_TREE) 2522 public List<JCExpression> getBounds() { 2523 return bounds; 2524 } 2525 @Override @DefinedBy(Api.COMPILER_TREE) 2526 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2527 return v.visitIntersectionType(this, d); 2528 } 2529 @Override 2530 public Tag getTag() { 2531 return TYPEINTERSECTION; 2532 } 2533 } 2534 2535 /** 2536 * A formal class parameter. 2537 */ 2538 public static class JCTypeParameter extends JCTree implements TypeParameterTree { 2539 /** name */ 2540 public Name name; 2541 /** bounds */ 2542 public List<JCExpression> bounds; 2543 /** type annotations on type parameter */ 2544 public List<JCAnnotation> annotations; 2545 protected JCTypeParameter(Name name, List<JCExpression> bounds, List<JCAnnotation> annotations) { 2546 this.name = name; 2547 this.bounds = bounds; 2548 this.annotations = annotations; 2549 } 2550 @Override 2551 public void accept(Visitor v) { v.visitTypeParameter(this); } 2552 2553 @DefinedBy(Api.COMPILER_TREE) 2554 public Kind getKind() { return Kind.TYPE_PARAMETER; } 2555 @DefinedBy(Api.COMPILER_TREE) 2556 public Name getName() { return name; } 2557 @DefinedBy(Api.COMPILER_TREE) 2558 public List<JCExpression> getBounds() { 2559 return bounds; 2560 } 2561 @DefinedBy(Api.COMPILER_TREE) 2562 public List<JCAnnotation> getAnnotations() { 2563 return annotations; 2564 } 2565 @Override @DefinedBy(Api.COMPILER_TREE) 2566 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2567 return v.visitTypeParameter(this, d); 2568 } 2569 @Override 2570 public Tag getTag() { 2571 return TYPEPARAMETER; 2572 } 2573 } 2574 2575 public static class JCWildcard extends JCExpression implements WildcardTree { 2576 public TypeBoundKind kind; 2577 public JCTree inner; 2578 protected JCWildcard(TypeBoundKind kind, JCTree inner) { 2579 this.kind = Assert.checkNonNull(kind); 2580 this.inner = inner; 2581 } 2582 @Override 2583 public void accept(Visitor v) { v.visitWildcard(this); } 2584 2585 @DefinedBy(Api.COMPILER_TREE) 2586 public Kind getKind() { 2587 switch (kind.kind) { 2588 case UNBOUND: 2589 return Kind.UNBOUNDED_WILDCARD; 2590 case EXTENDS: 2591 return Kind.EXTENDS_WILDCARD; 2592 case SUPER: 2593 return Kind.SUPER_WILDCARD; 2594 default: 2595 throw new AssertionError("Unknown wildcard bound " + kind); 2596 } 2597 } 2598 @DefinedBy(Api.COMPILER_TREE) 2599 public JCTree getBound() { return inner; } 2600 @Override @DefinedBy(Api.COMPILER_TREE) 2601 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2602 return v.visitWildcard(this, d); 2603 } 2604 @Override 2605 public Tag getTag() { 2606 return Tag.WILDCARD; 2607 } 2608 } 2609 2610 public static class TypeBoundKind extends JCTree { 2611 public BoundKind kind; 2612 protected TypeBoundKind(BoundKind kind) { 2613 this.kind = kind; 2614 } 2615 @Override 2616 public void accept(Visitor v) { v.visitTypeBoundKind(this); } 2617 2618 @DefinedBy(Api.COMPILER_TREE) 2619 public Kind getKind() { 2620 throw new AssertionError("TypeBoundKind is not part of a public API"); 2621 } 2622 @Override @DefinedBy(Api.COMPILER_TREE) 2623 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2624 throw new AssertionError("TypeBoundKind is not part of a public API"); 2625 } 2626 @Override 2627 public Tag getTag() { 2628 return TYPEBOUNDKIND; 2629 } 2630 } 2631 2632 public static class JCAnnotation extends JCExpression implements AnnotationTree { 2633 // Either Tag.ANNOTATION or Tag.TYPE_ANNOTATION 2634 private Tag tag; 2635 2636 public JCTree annotationType; 2637 public List<JCExpression> args; 2638 public Attribute.Compound attribute; 2639 2640 protected JCAnnotation(Tag tag, JCTree annotationType, List<JCExpression> args) { 2641 this.tag = tag; 2642 this.annotationType = annotationType; 2643 this.args = args; 2644 } 2645 2646 @Override 2647 public void accept(Visitor v) { v.visitAnnotation(this); } 2648 2649 @DefinedBy(Api.COMPILER_TREE) 2650 public Kind getKind() { return TreeInfo.tagToKind(getTag()); } 2651 2652 @DefinedBy(Api.COMPILER_TREE) 2653 public JCTree getAnnotationType() { return annotationType; } 2654 @DefinedBy(Api.COMPILER_TREE) 2655 public List<JCExpression> getArguments() { 2656 return args; 2657 } 2658 @Override @DefinedBy(Api.COMPILER_TREE) 2659 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2660 return v.visitAnnotation(this, d); 2661 } 2662 @Override 2663 public Tag getTag() { 2664 return tag; 2665 } 2666 } 2667 2668 public static class JCModifiers extends JCTree implements com.sun.source.tree.ModifiersTree { 2669 public long flags; 2670 public List<JCAnnotation> annotations; 2671 protected JCModifiers(long flags, List<JCAnnotation> annotations) { 2672 this.flags = flags; 2673 this.annotations = annotations; 2674 } 2675 @Override 2676 public void accept(Visitor v) { v.visitModifiers(this); } 2677 2678 @DefinedBy(Api.COMPILER_TREE) 2679 public Kind getKind() { return Kind.MODIFIERS; } 2680 @DefinedBy(Api.COMPILER_TREE) 2681 public Set<Modifier> getFlags() { 2682 return Flags.asModifierSet(flags); 2683 } 2684 @DefinedBy(Api.COMPILER_TREE) 2685 public List<JCAnnotation> getAnnotations() { 2686 return annotations; 2687 } 2688 @Override @DefinedBy(Api.COMPILER_TREE) 2689 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2690 return v.visitModifiers(this, d); 2691 } 2692 @Override 2693 public Tag getTag() { 2694 return MODIFIERS; 2695 } 2696 } 2697 2698 public static class JCAnnotatedType extends JCExpression implements com.sun.source.tree.AnnotatedTypeTree { 2699 // type annotations 2700 public List<JCAnnotation> annotations; 2701 public JCExpression underlyingType; 2702 2703 protected JCAnnotatedType(List<JCAnnotation> annotations, JCExpression underlyingType) { 2704 Assert.check(annotations != null && annotations.nonEmpty()); 2705 this.annotations = annotations; 2706 this.underlyingType = underlyingType; 2707 } 2708 @Override 2709 public void accept(Visitor v) { v.visitAnnotatedType(this); } 2710 2711 @DefinedBy(Api.COMPILER_TREE) 2712 public Kind getKind() { return Kind.ANNOTATED_TYPE; } 2713 @DefinedBy(Api.COMPILER_TREE) 2714 public List<JCAnnotation> getAnnotations() { 2715 return annotations; 2716 } 2717 @DefinedBy(Api.COMPILER_TREE) 2718 public JCExpression getUnderlyingType() { 2719 return underlyingType; 2720 } 2721 @Override @DefinedBy(Api.COMPILER_TREE) 2722 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 2723 return v.visitAnnotatedType(this, d); 2724 } 2725 @Override 2726 public Tag getTag() { 2727 return ANNOTATED_TYPE; 2728 } 2729 } 2730 2731 public static abstract class JCDirective extends JCTree 2732 implements DirectiveTree { 2733 } 2734 2735 public static class JCModuleDecl extends JCTree implements ModuleTree { 2736 public JCModifiers mods; 2737 public ModuleType type; 2738 private final ModuleKind kind; 2739 public JCExpression qualId; 2740 public List<JCDirective> directives; 2741 public ModuleSymbol sym; 2742 2743 protected JCModuleDecl(JCModifiers mods, ModuleKind kind, 2744 JCExpression qualId, List<JCDirective> directives) { 2745 this.mods = mods; 2746 this.kind = kind; 2747 this.qualId = qualId; 2748 this.directives = directives; 2749 } 2750 2751 @Override 2752 public void accept(Visitor v) { v.visitModuleDef(this); } 2753 2754 @Override @DefinedBy(Api.COMPILER_TREE) 2755 public Kind getKind() { 2756 return Kind.MODULE; 2757 } 2758 2759 @Override @DefinedBy(Api.COMPILER_TREE) 2760 public List<? extends AnnotationTree> getAnnotations() { 2761 return mods.annotations; 2762 } 2763 2764 @Override @DefinedBy(Api.COMPILER_TREE) 2765 public ModuleKind getModuleType() { 2766 return kind; 2767 } 2768 2769 @Override @DefinedBy(Api.COMPILER_TREE) 2770 public JCExpression getName() { 2771 return qualId; 2772 } 2773 2774 @Override @DefinedBy(Api.COMPILER_TREE) 2775 public List<JCDirective> getDirectives() { 2776 return directives; 2777 } 2778 2779 @Override @DefinedBy(Api.COMPILER_TREE) 2780 public <R, D> R accept(TreeVisitor<R, D> v, D d) { 2781 return v.visitModule(this, d); 2782 } 2783 2784 @Override 2785 public Tag getTag() { 2786 return MODULEDEF; 2787 } 2788 } 2789 2790 public static class JCExports extends JCDirective 2791 implements ExportsTree { 2792 public JCExpression qualid; 2793 public List<JCExpression> moduleNames; 2794 public ExportsDirective directive; 2795 2796 protected JCExports(JCExpression qualId, List<JCExpression> moduleNames) { 2797 this.qualid = qualId; 2798 this.moduleNames = moduleNames; 2799 } 2800 2801 @Override 2802 public void accept(Visitor v) { v.visitExports(this); } 2803 2804 @Override @DefinedBy(Api.COMPILER_TREE) 2805 public Kind getKind() { 2806 return Kind.EXPORTS; 2807 } 2808 2809 @Override @DefinedBy(Api.COMPILER_TREE) 2810 public JCExpression getPackageName() { 2811 return qualid; 2812 } 2813 2814 @Override @DefinedBy(Api.COMPILER_TREE) 2815 public List<JCExpression> getModuleNames() { 2816 return moduleNames; 2817 } 2818 2819 @Override @DefinedBy(Api.COMPILER_TREE) 2820 public <R, D> R accept(TreeVisitor<R, D> v, D d) { 2821 return v.visitExports(this, d); 2822 } 2823 2824 @Override 2825 public Tag getTag() { 2826 return Tag.EXPORTS; 2827 } 2828 } 2829 2830 public static class JCOpens extends JCDirective 2831 implements OpensTree { 2832 public JCExpression qualid; 2833 public List<JCExpression> moduleNames; 2834 public OpensDirective directive; 2835 2836 protected JCOpens(JCExpression qualId, List<JCExpression> moduleNames) { 2837 this.qualid = qualId; 2838 this.moduleNames = moduleNames; 2839 } 2840 2841 @Override 2842 public void accept(Visitor v) { v.visitOpens(this); } 2843 2844 @Override @DefinedBy(Api.COMPILER_TREE) 2845 public Kind getKind() { 2846 return Kind.OPENS; 2847 } 2848 2849 @Override @DefinedBy(Api.COMPILER_TREE) 2850 public JCExpression getPackageName() { 2851 return qualid; 2852 } 2853 2854 @Override @DefinedBy(Api.COMPILER_TREE) 2855 public List<JCExpression> getModuleNames() { 2856 return moduleNames; 2857 } 2858 2859 @Override @DefinedBy(Api.COMPILER_TREE) 2860 public <R, D> R accept(TreeVisitor<R, D> v, D d) { 2861 return v.visitOpens(this, d); 2862 } 2863 2864 @Override 2865 public Tag getTag() { 2866 return Tag.OPENS; 2867 } 2868 } 2869 2870 public static class JCProvides extends JCDirective 2871 implements ProvidesTree { 2872 public JCExpression serviceName; 2873 public List<JCExpression> implNames; 2874 2875 protected JCProvides(JCExpression serviceName, List<JCExpression> implNames) { 2876 this.serviceName = serviceName; 2877 this.implNames = implNames; 2878 } 2879 2880 @Override 2881 public void accept(Visitor v) { v.visitProvides(this); } 2882 2883 @Override @DefinedBy(Api.COMPILER_TREE) 2884 public Kind getKind() { 2885 return Kind.PROVIDES; 2886 } 2887 2888 @Override @DefinedBy(Api.COMPILER_TREE) 2889 public <R, D> R accept(TreeVisitor<R, D> v, D d) { 2890 return v.visitProvides(this, d); 2891 } 2892 2893 @Override @DefinedBy(Api.COMPILER_TREE) 2894 public JCExpression getServiceName() { 2895 return serviceName; 2896 } 2897 2898 @Override @DefinedBy(Api.COMPILER_TREE) 2899 public List<JCExpression> getImplementationNames() { 2900 return implNames; 2901 } 2902 2903 @Override 2904 public Tag getTag() { 2905 return PROVIDES; 2906 } 2907 } 2908 2909 public static class JCRequires extends JCDirective 2910 implements RequiresTree { 2911 public boolean isTransitive; 2912 public boolean isStaticPhase; 2913 public JCExpression moduleName; 2914 public RequiresDirective directive; 2915 2916 protected JCRequires(boolean isTransitive, boolean isStaticPhase, JCExpression moduleName) { 2917 this.isTransitive = isTransitive; 2918 this.isStaticPhase = isStaticPhase; 2919 this.moduleName = moduleName; 2920 } 2921 2922 @Override 2923 public void accept(Visitor v) { v.visitRequires(this); } 2924 2925 @Override @DefinedBy(Api.COMPILER_TREE) 2926 public Kind getKind() { 2927 return Kind.REQUIRES; 2928 } 2929 2930 @Override @DefinedBy(Api.COMPILER_TREE) 2931 public <R, D> R accept(TreeVisitor<R, D> v, D d) { 2932 return v.visitRequires(this, d); 2933 } 2934 2935 @Override @DefinedBy(Api.COMPILER_TREE) 2936 public boolean isTransitive() { 2937 return isTransitive; 2938 } 2939 2940 @Override @DefinedBy(Api.COMPILER_TREE) 2941 public boolean isStatic() { 2942 return isStaticPhase; 2943 } 2944 2945 @Override @DefinedBy(Api.COMPILER_TREE) 2946 public JCExpression getModuleName() { 2947 return moduleName; 2948 } 2949 2950 @Override 2951 public Tag getTag() { 2952 return REQUIRES; 2953 } 2954 } 2955 2956 public static class JCUses extends JCDirective 2957 implements UsesTree { 2958 public JCExpression qualid; 2959 2960 protected JCUses(JCExpression qualId) { 2961 this.qualid = qualId; 2962 } 2963 2964 @Override 2965 public void accept(Visitor v) { v.visitUses(this); } 2966 2967 @Override @DefinedBy(Api.COMPILER_TREE) 2968 public Kind getKind() { 2969 return Kind.USES; 2970 } 2971 2972 @Override @DefinedBy(Api.COMPILER_TREE) 2973 public JCExpression getServiceName() { 2974 return qualid; 2975 } 2976 2977 @Override @DefinedBy(Api.COMPILER_TREE) 2978 public <R, D> R accept(TreeVisitor<R, D> v, D d) { 2979 return v.visitUses(this, d); 2980 } 2981 2982 @Override 2983 public Tag getTag() { 2984 return USES; 2985 } 2986 } 2987 2988 public static class JCErroneous extends JCExpression 2989 implements ErroneousTree { 2990 public List<? extends JCTree> errs; 2991 protected JCErroneous(List<? extends JCTree> errs) { 2992 this.errs = errs; 2993 } 2994 @Override 2995 public void accept(Visitor v) { v.visitErroneous(this); } 2996 2997 @DefinedBy(Api.COMPILER_TREE) 2998 public Kind getKind() { return Kind.ERRONEOUS; } 2999 3000 @DefinedBy(Api.COMPILER_TREE) 3001 public List<? extends JCTree> getErrorTrees() { 3002 return errs; 3003 } 3004 3005 @Override @DefinedBy(Api.COMPILER_TREE) 3006 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 3007 return v.visitErroneous(this, d); 3008 } 3009 @Override 3010 public Tag getTag() { 3011 return ERRONEOUS; 3012 } 3013 } 3014 3015 /** (let int x = 3; in x+2) */ 3016 public static class LetExpr extends JCExpression { 3017 public List<JCStatement> defs; 3018 public JCExpression expr; 3019 protected LetExpr(List<JCStatement> defs, JCExpression expr) { 3020 this.defs = defs; 3021 this.expr = expr; 3022 } 3023 @Override 3024 public void accept(Visitor v) { v.visitLetExpr(this); } 3025 3026 @DefinedBy(Api.COMPILER_TREE) 3027 public Kind getKind() { 3028 throw new AssertionError("LetExpr is not part of a public API"); 3029 } 3030 @Override @DefinedBy(Api.COMPILER_TREE) 3031 public <R,D> R accept(TreeVisitor<R,D> v, D d) { 3032 throw new AssertionError("LetExpr is not part of a public API"); 3033 } 3034 @Override 3035 public Tag getTag() { 3036 return LETEXPR; 3037 } 3038 } 3039 3040 /** An interface for tree factories 3041 */ 3042 public interface Factory { 3043 JCCompilationUnit TopLevel(List<JCTree> defs); 3044 JCPackageDecl PackageDecl(List<JCAnnotation> annotations, 3045 JCExpression pid); 3046 JCImport Import(JCTree qualid, boolean staticImport); 3047 JCClassDecl ClassDef(JCModifiers mods, 3048 Name name, 3049 List<JCTypeParameter> typarams, 3050 JCExpression extending, 3051 List<JCExpression> implementing, 3052 List<JCTree> defs); 3053 JCMethodDecl MethodDef(JCModifiers mods, 3054 Name name, 3055 JCExpression restype, 3056 List<JCTypeParameter> typarams, 3057 JCVariableDecl recvparam, 3058 List<JCVariableDecl> params, 3059 List<JCExpression> thrown, 3060 JCBlock body, 3061 JCExpression defaultValue); 3062 JCVariableDecl VarDef(JCModifiers mods, 3063 Name name, 3064 JCExpression vartype, 3065 JCExpression init); 3066 JCSkip Skip(); 3067 JCBlock Block(long flags, List<JCStatement> stats); 3068 JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond); 3069 JCWhileLoop WhileLoop(JCExpression cond, JCStatement body); 3070 JCForLoop ForLoop(List<JCStatement> init, 3071 JCExpression cond, 3072 List<JCExpressionStatement> step, 3073 JCStatement body); 3074 JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body); 3075 JCLabeledStatement Labelled(Name label, JCStatement body); 3076 JCSwitch Switch(JCExpression selector, List<JCCase> cases); 3077 JCSwitchExpression SwitchExpression(JCExpression selector, List<JCCase> cases); 3078 JCCase Case(@SuppressWarnings("removal") CaseKind caseKind, List<JCExpression> pat, 3079 List<JCStatement> stats, JCTree body); 3080 JCSynchronized Synchronized(JCExpression lock, JCBlock body); 3081 JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer); 3082 JCTry Try(List<JCTree> resources, 3083 JCBlock body, 3084 List<JCCatch> catchers, 3085 JCBlock finalizer); 3086 JCCatch Catch(JCVariableDecl param, JCBlock body); 3087 JCConditional Conditional(JCExpression cond, 3088 JCExpression thenpart, 3089 JCExpression elsepart); 3090 JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart); 3091 JCExpressionStatement Exec(JCExpression expr); 3092 JCBreak Break(JCExpression value); 3093 JCContinue Continue(Name label); 3094 JCReturn Return(JCExpression expr); 3095 JCThrow Throw(JCExpression expr); 3096 JCAssert Assert(JCExpression cond, JCExpression detail); 3097 JCMethodInvocation Apply(List<JCExpression> typeargs, 3098 JCExpression fn, 3099 List<JCExpression> args); 3100 JCNewClass NewClass(JCExpression encl, 3101 List<JCExpression> typeargs, 3102 JCExpression clazz, 3103 List<JCExpression> args, 3104 JCClassDecl def); 3105 JCNewArray NewArray(JCExpression elemtype, 3106 List<JCExpression> dims, 3107 List<JCExpression> elems); 3108 JCParens Parens(JCExpression expr); 3109 JCAssign Assign(JCExpression lhs, JCExpression rhs); 3110 JCAssignOp Assignop(Tag opcode, JCTree lhs, JCTree rhs); 3111 JCUnary Unary(Tag opcode, JCExpression arg); 3112 JCBinary Binary(Tag opcode, JCExpression lhs, JCExpression rhs); 3113 JCTypeCast TypeCast(JCTree expr, JCExpression type); 3114 JCInstanceOf TypeTest(JCExpression expr, JCTree clazz); 3115 JCArrayAccess Indexed(JCExpression indexed, JCExpression index); 3116 JCFieldAccess Select(JCExpression selected, Name selector); 3117 JCIdent Ident(Name idname); 3118 JCLiteral Literal(TypeTag tag, Object value); 3119 JCPrimitiveTypeTree TypeIdent(TypeTag typetag); 3120 JCArrayTypeTree TypeArray(JCExpression elemtype); 3121 JCTypeApply TypeApply(JCExpression clazz, List<JCExpression> arguments); 3122 JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds); 3123 JCWildcard Wildcard(TypeBoundKind kind, JCTree type); 3124 TypeBoundKind TypeBoundKind(BoundKind kind); 3125 JCAnnotation Annotation(JCTree annotationType, List<JCExpression> args); 3126 JCModifiers Modifiers(long flags, List<JCAnnotation> annotations); 3127 JCErroneous Erroneous(List<? extends JCTree> errs); 3128 JCModuleDecl ModuleDef(JCModifiers mods, ModuleKind kind, JCExpression qualId, List<JCDirective> directives); 3129 JCExports Exports(JCExpression qualId, List<JCExpression> moduleNames); 3130 JCOpens Opens(JCExpression qualId, List<JCExpression> moduleNames); 3131 JCProvides Provides(JCExpression serviceName, List<JCExpression> implNames); 3132 JCRequires Requires(boolean isTransitive, boolean isStaticPhase, JCExpression qualId); 3133 JCUses Uses(JCExpression qualId); 3134 LetExpr LetExpr(List<JCStatement> defs, JCExpression expr); 3135 } 3136 3137 /** A generic visitor class for trees. 3138 */ 3139 public static abstract class Visitor { 3140 public void visitTopLevel(JCCompilationUnit that) { visitTree(that); } 3141 public void visitPackageDef(JCPackageDecl that) { visitTree(that); } 3142 public void visitImport(JCImport that) { visitTree(that); } 3143 public void visitClassDef(JCClassDecl that) { visitTree(that); } 3144 public void visitMethodDef(JCMethodDecl that) { visitTree(that); } 3145 public void visitVarDef(JCVariableDecl that) { visitTree(that); } 3146 public void visitSkip(JCSkip that) { visitTree(that); } 3147 public void visitBlock(JCBlock that) { visitTree(that); } 3148 public void visitDoLoop(JCDoWhileLoop that) { visitTree(that); } 3149 public void visitWhileLoop(JCWhileLoop that) { visitTree(that); } 3150 public void visitForLoop(JCForLoop that) { visitTree(that); } 3151 public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); } 3152 public void visitLabelled(JCLabeledStatement that) { visitTree(that); } 3153 public void visitSwitch(JCSwitch that) { visitTree(that); } 3154 public void visitCase(JCCase that) { visitTree(that); } 3155 public void visitSwitchExpression(JCSwitchExpression that) { visitTree(that); } 3156 public void visitSynchronized(JCSynchronized that) { visitTree(that); } 3157 public void visitTry(JCTry that) { visitTree(that); } 3158 public void visitCatch(JCCatch that) { visitTree(that); } 3159 public void visitConditional(JCConditional that) { visitTree(that); } 3160 public void visitIf(JCIf that) { visitTree(that); } 3161 public void visitExec(JCExpressionStatement that) { visitTree(that); } 3162 public void visitBreak(JCBreak that) { visitTree(that); } 3163 public void visitContinue(JCContinue that) { visitTree(that); } 3164 public void visitReturn(JCReturn that) { visitTree(that); } 3165 public void visitThrow(JCThrow that) { visitTree(that); } 3166 public void visitAssert(JCAssert that) { visitTree(that); } 3167 public void visitApply(JCMethodInvocation that) { visitTree(that); } 3168 public void visitNewClass(JCNewClass that) { visitTree(that); } 3169 public void visitNewArray(JCNewArray that) { visitTree(that); } 3170 public void visitLambda(JCLambda that) { visitTree(that); } 3171 public void visitParens(JCParens that) { visitTree(that); } 3172 public void visitAssign(JCAssign that) { visitTree(that); } 3173 public void visitAssignop(JCAssignOp that) { visitTree(that); } 3174 public void visitUnary(JCUnary that) { visitTree(that); } 3175 public void visitBinary(JCBinary that) { visitTree(that); } 3176 public void visitTypeCast(JCTypeCast that) { visitTree(that); } 3177 public void visitTypeTest(JCInstanceOf that) { visitTree(that); } 3178 public void visitIndexed(JCArrayAccess that) { visitTree(that); } 3179 public void visitSelect(JCFieldAccess that) { visitTree(that); } 3180 public void visitReference(JCMemberReference that) { visitTree(that); } 3181 public void visitIdent(JCIdent that) { visitTree(that); } 3182 public void visitLiteral(JCLiteral that) { visitTree(that); } 3183 public void visitTypeIdent(JCPrimitiveTypeTree that) { visitTree(that); } 3184 public void visitTypeArray(JCArrayTypeTree that) { visitTree(that); } 3185 public void visitTypeApply(JCTypeApply that) { visitTree(that); } 3186 public void visitTypeUnion(JCTypeUnion that) { visitTree(that); } 3187 public void visitTypeIntersection(JCTypeIntersection that) { visitTree(that); } 3188 public void visitTypeParameter(JCTypeParameter that) { visitTree(that); } 3189 public void visitWildcard(JCWildcard that) { visitTree(that); } 3190 public void visitTypeBoundKind(TypeBoundKind that) { visitTree(that); } 3191 public void visitAnnotation(JCAnnotation that) { visitTree(that); } 3192 public void visitModifiers(JCModifiers that) { visitTree(that); } 3193 public void visitAnnotatedType(JCAnnotatedType that) { visitTree(that); } 3194 public void visitErroneous(JCErroneous that) { visitTree(that); } 3195 public void visitModuleDef(JCModuleDecl that) { visitTree(that); } 3196 public void visitExports(JCExports that) { visitTree(that); } 3197 public void visitOpens(JCOpens that) { visitTree(that); } 3198 public void visitProvides(JCProvides that) { visitTree(that); } 3199 public void visitRequires(JCRequires that) { visitTree(that); } 3200 public void visitUses(JCUses that) { visitTree(that); } 3201 public void visitLetExpr(LetExpr that) { visitTree(that); } 3202 3203 public void visitTree(JCTree that) { Assert.error(); } 3204 } 3205 3206 }