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