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