1 /*
   2  * Copyright (c) 1999, 2021, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.tools.javac.tree;
  27 
  28 import java.io.IOException;
  29 import java.io.StringWriter;
  30 import java.util.*;
  31 
  32 import javax.lang.model.element.Modifier;
  33 import javax.lang.model.type.TypeKind;
  34 import javax.tools.JavaFileObject;
  35 
  36 import com.sun.source.tree.*;
  37 import com.sun.tools.javac.code.*;
  38 import com.sun.tools.javac.code.Directive.RequiresDirective;
  39 import com.sun.tools.javac.code.Scope.*;
  40 import com.sun.tools.javac.code.Symbol.*;
  41 import com.sun.tools.javac.util.*;
  42 import com.sun.tools.javac.util.DefinedBy.Api;
  43 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
  44 import com.sun.tools.javac.util.List;
  45 
  46 import static com.sun.tools.javac.tree.JCTree.Tag.*;
  47 
  48 import javax.tools.JavaFileManager.Location;
  49 
  50 import com.sun.source.tree.ModuleTree.ModuleKind;
  51 import com.sun.tools.javac.code.Directive.ExportsDirective;
  52 import com.sun.tools.javac.code.Directive.OpensDirective;
  53 import com.sun.tools.javac.code.Type.ModuleType;
  54 
  55 /**
  56  * Root class for abstract syntax tree nodes. It provides definitions
  57  * for specific tree nodes as subclasses nested inside.
  58  *
  59  * <p>Each subclass is highly standardized.  It generally contains
  60  * only tree fields for the syntactic subcomponents of the node.  Some
  61  * classes that represent identifier uses or definitions also define a
  62  * Symbol field that denotes the represented identifier.  Classes for
  63  * non-local jumps also carry the jump target as a field.  The root
  64  * class Tree itself defines fields for the tree's type and position.
  65  * No other fields are kept in a tree node; instead parameters are
  66  * passed to methods accessing the node.
  67  *
  68  * <p>Except for the methods defined by com.sun.source, the only
  69  * method defined in subclasses is `visit' which applies a given
  70  * visitor to the tree. The actual tree processing is done by visitor
  71  * classes in other packages. The abstract class Visitor, as well as
  72  * an Factory interface for trees, are defined as inner classes in
  73  * Tree.
  74  *
  75  * <p>To avoid ambiguities with the Tree API in com.sun.source all sub
  76  * classes should, by convention, start with JC (javac).
  77  *
  78  * <p><b>This is NOT part of any supported API.
  79  * If you write code that depends on this, you do so at your own risk.
  80  * This code and its internal interfaces are subject to change or
  81  * deletion without notice.</b>
  82  *
  83  * @see TreeMaker
  84  * @see TreeInfo
  85  * @see TreeTranslator
  86  * @see Pretty
  87  */
  88 public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
  89 
  90     /* Tree tag values, identifying kinds of trees */
  91     public enum Tag {
  92         /** For methods that return an invalid tag if a given condition is not met
  93          */
  94         NO_TAG,
  95 
  96         /** Toplevel nodes, of type TopLevel, representing entire source files.
  97         */
  98         TOPLEVEL,
  99 
 100         /** Package level definitions.
 101          */
 102         PACKAGEDEF,
 103 
 104         /** Import clauses, of type Import.
 105          */
 106         IMPORT,
 107 
 108         /** Class definitions, of type ClassDef.
 109          */
 110         CLASSDEF,
 111 
 112         /** Method definitions, of type MethodDef.
 113          */
 114         METHODDEF,
 115 
 116         /** Variable definitions, of type VarDef.
 117          */
 118         VARDEF,
 119 
 120         /** The no-op statement ";", of type Skip
 121          */
 122         SKIP,
 123 
 124         /** Blocks, of type Block.
 125          */
 126         BLOCK,
 127 
 128         /** Do-while loops, of type DoLoop.
 129          */
 130         DOLOOP,
 131 
 132         /** While-loops, of type WhileLoop.
 133          */
 134         WHILELOOP,
 135 




 136         /** 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         BINDINGPATTERN,
 243         DEFAULTCASELABEL,
 244         GUARDPATTERN,
 245         PARENTHESIZEDPATTERN,
 246 
 247         /** Indexed array expressions, of type Indexed.
 248          */
 249         INDEXED,
 250 
 251         /** Selections, of type Select.
 252          */
 253         SELECT,
 254 




 255         /** Member references, of type Reference.
 256          */
 257         REFERENCE,
 258 
 259         /** Simple identifiers, of type Ident.
 260          */
 261         IDENT,
 262 
 263         /** Literals, of type Literal.
 264          */
 265         LITERAL,
 266 
 267         /** Basic type identifiers, of type TypeIdent.
 268          */
 269         TYPEIDENT,
 270 
 271         /** Array types, of type TypeArray.
 272          */
 273         TYPEARRAY,
 274 
 275         /** Parameterized types, of type TypeApply.
 276          */
 277         TYPEAPPLY,
 278 
 279         /** Union types, of type TypeUnion.
 280          */
 281         TYPEUNION,
 282 
 283         /** Intersection types, of type TypeIntersection.
 284          */
 285         TYPEINTERSECTION,
 286 
 287         /** Formal type parameters, of type TypeParameter.
 288          */
 289         TYPEPARAMETER,
 290 
 291         /** Type argument.
 292          */
 293         WILDCARD,
 294 
 295         /** Bound kind: extends, super, exact, or unbound
 296          */
 297         TYPEBOUNDKIND,
 298 
 299         /** metadata: Annotation.
 300          */
 301         ANNOTATION,
 302 
 303         /** metadata: Type annotation.
 304          */
 305         TYPE_ANNOTATION,
 306 
 307         /** metadata: Modifiers
 308          */
 309         MODIFIERS,
 310 
 311         /** An annotated type tree.
 312          */
 313         ANNOTATED_TYPE,
 314 
 315         /** Error trees, of type Erroneous.
 316          */
 317         ERRONEOUS,
 318 
 319         /** Unary operators, of type Unary.
 320          */
 321         POS,                             // +
 322         NEG,                             // -
 323         NOT,                             // !
 324         COMPL,                           // ~
 325         PREINC,                          // ++ _
 326         PREDEC,                          // -- _
 327         POSTINC,                         // _ ++
 328         POSTDEC,                         // _ --
 329 
 330         /** unary operator for null reference checks, only used internally.
 331          */
 332         NULLCHK,
 333 
 334         /** Binary operators, of type Binary.
 335          */
 336         OR,                              // ||
 337         AND,                             // &&
 338         BITOR,                           // |
 339         BITXOR,                          // ^
 340         BITAND,                          // &
 341         EQ,                              // ==
 342         NE,                              // !=
 343         LT,                              // <
 344         GT,                              // >
 345         LE,                              // <=
 346         GE,                              // >=
 347         SL,                              // <<
 348         SR,                              // >>
 349         USR,                             // >>>
 350         PLUS,                            // +
 351         MINUS,                           // -
 352         MUL,                             // *
 353         DIV,                             // /
 354         MOD,                             // %
 355 
 356         /** Assignment operators, of type Assignop.
 357          */
 358         BITOR_ASG(BITOR),                // |=
 359         BITXOR_ASG(BITXOR),              // ^=
 360         BITAND_ASG(BITAND),              // &=
 361 
 362         SL_ASG(SL),                      // <<=
 363         SR_ASG(SR),                      // >>=
 364         USR_ASG(USR),                    // >>>=
 365         PLUS_ASG(PLUS),                  // +=
 366         MINUS_ASG(MINUS),                // -=
 367         MUL_ASG(MUL),                    // *=
 368         DIV_ASG(DIV),                    // /=
 369         MOD_ASG(MOD),                    // %=
 370 
 371         MODULEDEF,
 372         EXPORTS,
 373         OPENS,
 374         PROVIDES,
 375         REQUIRES,
 376         USES,
 377 
 378         /** A synthetic let expression, of type LetExpr.
 379          */
 380         LETEXPR;                         // ala scheme
 381 
 382         private final Tag noAssignTag;
 383 
 384         private static final int numberOfOperators = MOD.ordinal() - POS.ordinal() + 1;
 385 
 386         private Tag(Tag noAssignTag) {
 387             this.noAssignTag = noAssignTag;
 388         }
 389 
 390         private Tag() {
 391             this(null);
 392         }
 393 
 394         public static int getNumberOfOperators() {
 395             return numberOfOperators;
 396         }
 397 
 398         public Tag noAssignOp() {
 399             if (noAssignTag != null)
 400                 return noAssignTag;
 401             throw new AssertionError("noAssignOp() method is not available for non assignment tags");
 402         }
 403 
 404         public boolean isPostUnaryOp() {
 405             return (this == POSTINC || this == POSTDEC);
 406         }
 407 
 408         public boolean isIncOrDecUnaryOp() {
 409             return (this == PREINC || this == PREDEC || this == POSTINC || this == POSTDEC);
 410         }
 411 
 412         public boolean isAssignop() {
 413             return noAssignTag != null;
 414         }
 415 
 416         public int operatorIndex() {
 417             return (this.ordinal() - POS.ordinal());
 418         }
 419     }
 420 
 421     /* The (encoded) position in the source file. @see util.Position.
 422      */
 423     public int pos;
 424 
 425     /* The type of this node.
 426      */
 427     public Type type;
 428 
 429     /* The tag of this node -- one of the constants declared above.
 430      */
 431     public abstract Tag getTag();
 432 
 433     /* Returns true if the tag of this node is equals to tag.
 434      */
 435     public boolean hasTag(Tag tag) {
 436         return tag == getTag();
 437     }
 438 
 439     /** Convert a tree to a pretty-printed string. */
 440     @Override
 441     public String toString() {
 442         StringWriter s = new StringWriter();
 443         try {
 444             new Pretty(s, false).printExpr(this);
 445         }
 446         catch (IOException e) {
 447             // should never happen, because StringWriter is defined
 448             // never to throw any IOExceptions
 449             throw new AssertionError(e);
 450         }
 451         return s.toString();
 452     }
 453 
 454     /** Set position field and return this tree.
 455      */
 456     public JCTree setPos(int pos) {
 457         this.pos = pos;
 458         return this;
 459     }
 460 
 461     /** Set type field and return this tree.
 462      */
 463     public JCTree setType(Type type) {
 464         this.type = type;
 465         return this;
 466     }
 467 
 468     /** Visit this tree with a given visitor.
 469      */
 470     public abstract void accept(Visitor v);
 471 
 472     @DefinedBy(Api.COMPILER_TREE)
 473     public abstract <R,D> R accept(TreeVisitor<R,D> v, D d);
 474 
 475     /** Return a shallow copy of this tree.
 476      */
 477     @Override
 478     public Object clone() {
 479         try {
 480             return super.clone();
 481         } catch(CloneNotSupportedException e) {
 482             throw new RuntimeException(e);
 483         }
 484     }
 485 
 486     /** Get a default position for this tree node.
 487      */
 488     public DiagnosticPosition pos() {
 489         return this;
 490     }
 491 
 492     // for default DiagnosticPosition
 493     public JCTree getTree() {
 494         return this;
 495     }
 496 
 497     // for default DiagnosticPosition
 498     public int getStartPosition() {
 499         return TreeInfo.getStartPos(this);
 500     }
 501 
 502     // for default DiagnosticPosition
 503     public int getPreferredPosition() {
 504         return pos;
 505     }
 506 
 507     // for default DiagnosticPosition
 508     public int getEndPosition(EndPosTable endPosTable) {
 509         return TreeInfo.getEndPos(this, endPosTable);
 510     }
 511 
 512     /**
 513      * Everything in one source file is kept in a {@linkplain JCCompilationUnit} structure.
 514      */
 515     public static class JCCompilationUnit extends JCTree implements CompilationUnitTree {
 516         /** All definitions in this file (ClassDef, Import, and Skip) */
 517         public List<JCTree> defs;
 518         /** The source file name. */
 519         public JavaFileObject sourcefile;
 520         /** The module to which this compilation unit belongs. */
 521         public ModuleSymbol modle;
 522         /** The location in which this compilation unit was found. */
 523         public Location locn;
 524         /** The package to which this compilation unit belongs. */
 525         public PackageSymbol packge;
 526         /** A scope containing top level classes. */
 527         public WriteableScope toplevelScope;
 528         /** A scope for all named imports. */
 529         public NamedImportScope namedImportScope;
 530         /** A scope for all import-on-demands. */
 531         public StarImportScope starImportScope;
 532         /** Line starting positions, defined only if option -g is set. */
 533         public Position.LineMap lineMap = null;
 534         /** A table that stores all documentation comments indexed by the tree
 535          * nodes they refer to. defined only if option -s is set. */
 536         public DocCommentTable docComments = null;
 537         /* An object encapsulating ending positions of source ranges indexed by
 538          * the tree nodes they belong to. Defined only if option -Xjcov is set. */
 539         public EndPosTable endPositions = null;
 540         protected JCCompilationUnit(List<JCTree> defs) {
 541             this.defs = defs;
 542         }
 543         @Override
 544         public void accept(Visitor v) { v.visitTopLevel(this); }
 545 
 546         @DefinedBy(Api.COMPILER_TREE)
 547         public Kind getKind() { return Kind.COMPILATION_UNIT; }
 548 
 549         public JCModuleDecl getModuleDecl() {
 550             for (JCTree tree : defs) {
 551                 if (tree.hasTag(MODULEDEF)) {
 552                     return (JCModuleDecl) tree;
 553                 }
 554             }
 555 
 556             return null;
 557         }
 558 
 559         @DefinedBy(Api.COMPILER_TREE)
 560         public JCModuleDecl getModule() {
 561             return getModuleDecl();
 562         }
 563 
 564         @DefinedBy(Api.COMPILER_TREE)
 565         public JCPackageDecl getPackage() {
 566             // PackageDecl must be the first entry if it exists
 567             if (!defs.isEmpty() && defs.head.hasTag(PACKAGEDEF))
 568                 return (JCPackageDecl)defs.head;
 569             return null;
 570         }
 571         @DefinedBy(Api.COMPILER_TREE)
 572         public List<JCAnnotation> getPackageAnnotations() {
 573             JCPackageDecl pd = getPackage();
 574             return pd != null ? pd.getAnnotations() : List.nil();
 575         }
 576         @DefinedBy(Api.COMPILER_TREE)
 577         public ExpressionTree getPackageName() {
 578             JCPackageDecl pd = getPackage();
 579             return pd != null ? pd.getPackageName() : null;
 580         }
 581 
 582         @DefinedBy(Api.COMPILER_TREE)
 583         public List<JCImport> getImports() {
 584             ListBuffer<JCImport> imports = new ListBuffer<>();
 585             for (JCTree tree : defs) {
 586                 if (tree.hasTag(IMPORT))
 587                     imports.append((JCImport)tree);
 588                 else if (!tree.hasTag(PACKAGEDEF) && !tree.hasTag(SKIP))
 589                     break;
 590             }
 591             return imports.toList();
 592         }
 593         @DefinedBy(Api.COMPILER_TREE)
 594         public JavaFileObject getSourceFile() {
 595             return sourcefile;
 596         }
 597         @DefinedBy(Api.COMPILER_TREE)
 598         public Position.LineMap getLineMap() {
 599             return lineMap;
 600         }
 601         @DefinedBy(Api.COMPILER_TREE)
 602         public List<JCTree> getTypeDecls() {
 603             List<JCTree> typeDefs;
 604             for (typeDefs = defs; !typeDefs.isEmpty(); typeDefs = typeDefs.tail) {
 605                 if (!typeDefs.head.hasTag(MODULEDEF)
 606                         && !typeDefs.head.hasTag(PACKAGEDEF) && !typeDefs.head.hasTag(IMPORT)) {
 607                     break;
 608                 }
 609             }
 610             return typeDefs;
 611         }
 612         @Override @DefinedBy(Api.COMPILER_TREE)
 613         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
 614             return v.visitCompilationUnit(this, d);
 615         }
 616 
 617         @Override
 618         public Tag getTag() {
 619             return TOPLEVEL;
 620         }
 621     }
 622 
 623     /**
 624      * Package definition.
 625      */
 626     public static class JCPackageDecl extends JCTree implements PackageTree {
 627         public List<JCAnnotation> annotations;
 628         /** The tree representing the package clause. */
 629         public JCExpression pid;
 630         public PackageSymbol packge;
 631         public JCPackageDecl(List<JCAnnotation> annotations, JCExpression pid) {
 632             this.annotations = annotations;
 633             this.pid = pid;
 634         }
 635         @Override
 636         public void accept(Visitor v) { v.visitPackageDef(this); }
 637         @DefinedBy(Api.COMPILER_TREE)
 638         public Kind getKind() {
 639             return Kind.PACKAGE;
 640         }
 641         @DefinedBy(Api.COMPILER_TREE)
 642         public List<JCAnnotation> getAnnotations() {
 643             return annotations;
 644         }
 645         @DefinedBy(Api.COMPILER_TREE)
 646         public JCExpression getPackageName() {
 647             return pid;
 648         }
 649         @Override @DefinedBy(Api.COMPILER_TREE)
 650         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
 651             return v.visitPackage(this, d);
 652         }
 653         @Override
 654         public Tag getTag() {
 655             return PACKAGEDEF;
 656         }
 657     }
 658 
 659     /**
 660      * An import clause.
 661      */
 662     public static class JCImport extends JCTree implements ImportTree {
 663         public boolean staticImport;
 664         /** The imported class(es). */
 665         public JCTree qualid;
 666         public com.sun.tools.javac.code.Scope importScope;
 667         protected JCImport(JCTree qualid, boolean importStatic) {
 668             this.qualid = qualid;
 669             this.staticImport = importStatic;
 670         }
 671         @Override
 672         public void accept(Visitor v) { v.visitImport(this); }
 673 
 674         @DefinedBy(Api.COMPILER_TREE)
 675         public boolean isStatic() { return staticImport; }
 676         @DefinedBy(Api.COMPILER_TREE)
 677         public JCTree getQualifiedIdentifier() { return qualid; }
 678 
 679         @DefinedBy(Api.COMPILER_TREE)
 680         public Kind getKind() { return Kind.IMPORT; }
 681         @Override @DefinedBy(Api.COMPILER_TREE)
 682         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
 683             return v.visitImport(this, d);
 684         }
 685 
 686         @Override
 687         public Tag getTag() {
 688             return IMPORT;
 689         }
 690     }
 691 
 692     public abstract static class JCStatement extends JCTree implements StatementTree {
 693         @Override
 694         public JCStatement setType(Type type) {
 695             super.setType(type);
 696             return this;
 697         }
 698         @Override
 699         public JCStatement setPos(int pos) {
 700             super.setPos(pos);
 701             return this;
 702         }
 703     }
 704 
 705     public abstract static class JCCaseLabel extends JCTree implements CaseLabelTree {
 706         public abstract boolean isExpression();
 707         public boolean isNullPattern() {
 708             return isExpression() && TreeInfo.isNull((JCExpression) this);
 709         }
 710         public abstract boolean isPattern();
 711     }
 712 
 713     public abstract static class JCExpression extends JCCaseLabel implements ExpressionTree {
 714         @Override
 715         public JCExpression setType(Type type) {
 716             super.setType(type);
 717             return this;
 718         }
 719         @Override
 720         public JCExpression setPos(int pos) {
 721             super.setPos(pos);
 722             return this;
 723         }
 724 
 725         public boolean isPoly() { return false; }
 726         public boolean isStandalone() { return true; }
 727 
 728         @Override
 729         public boolean isExpression() {
 730             return true;
 731         }
 732 
 733         @Override
 734         public boolean isPattern() {
 735             return false;
 736         }
 737     }
 738 
 739     /**
 740      * Common supertype for all poly expression trees (lambda, method references,
 741      * conditionals, method and constructor calls)
 742      */
 743     public abstract static class JCPolyExpression extends JCExpression {
 744 
 745         /**
 746          * A poly expression can only be truly 'poly' in certain contexts
 747          */
 748         public enum PolyKind {
 749             /** poly expression to be treated as a standalone expression */
 750             STANDALONE,
 751             /** true poly expression */
 752             POLY
 753         }
 754 
 755         /** is this poly expression a 'true' poly expression? */
 756         public PolyKind polyKind;
 757 
 758         @Override public boolean isPoly() { return polyKind == PolyKind.POLY; }
 759         @Override public boolean isStandalone() { return polyKind == PolyKind.STANDALONE; }
 760     }
 761 
 762     /**
 763      * Common supertype for all functional expression trees (lambda and method references)
 764      */
 765     public abstract static class JCFunctionalExpression extends JCPolyExpression {
 766 
 767         public JCFunctionalExpression() {
 768             //a functional expression is always a 'true' poly
 769             polyKind = PolyKind.POLY;
 770         }
 771 
 772         /** list of target types inferred for this functional expression. */
 773         public Type target;
 774 
 775         public Type getDescriptorType(Types types) {
 776             return target != null ? types.findDescriptorType(target) : types.createErrorType(null);
 777         }
 778     }
 779 
 780     /**
 781      * A class definition.
 782      */
 783     public static class JCClassDecl extends JCStatement implements ClassTree {
 784         /** the modifiers */
 785         public JCModifiers mods;
 786         /** the name of the class */
 787         public Name name;
 788         /** formal class parameters */
 789         public List<JCTypeParameter> typarams;
 790         /** the classes this class extends */
 791         public JCExpression extending;
 792         /** the interfaces implemented by this class */
 793         public List<JCExpression> implementing;
 794         /** the subclasses allowed to extend this class, if sealed */
 795         public List<JCExpression> permitting;
 796         /** all variables and methods defined in this class */
 797         public List<JCTree> defs;
 798         /** the symbol */
 799         public ClassSymbol sym;
 800         protected JCClassDecl(JCModifiers mods,
 801                            Name name,
 802                            List<JCTypeParameter> typarams,
 803                            JCExpression extending,
 804                            List<JCExpression> implementing,
 805                            List<JCExpression> permitting,
 806                            List<JCTree> defs,
 807                            ClassSymbol sym)
 808         {
 809             this.mods = mods;
 810             this.name = name;
 811             this.typarams = typarams;
 812             this.extending = extending;
 813             this.implementing = implementing;
 814             this.permitting = permitting;
 815             this.defs = defs;
 816             this.sym = sym;
 817         }
 818         @Override
 819         public void accept(Visitor v) { v.visitClassDef(this); }
 820 
 821         @DefinedBy(Api.COMPILER_TREE)
 822         public Kind getKind() {
 823             if ((mods.flags & Flags.ANNOTATION) != 0)
 824                 return Kind.ANNOTATION_TYPE;
 825             else if ((mods.flags & Flags.INTERFACE) != 0)
 826                 return Kind.INTERFACE;
 827             else if ((mods.flags & Flags.ENUM) != 0)
 828                 return Kind.ENUM;
 829             else if ((mods.flags & Flags.RECORD) != 0)
 830                 return Kind.RECORD;
 831             else
 832                 return Kind.CLASS;
 833         }
 834 
 835         @DefinedBy(Api.COMPILER_TREE)
 836         public JCModifiers getModifiers() { return mods; }
 837         @DefinedBy(Api.COMPILER_TREE)
 838         public Name getSimpleName() { return name; }
 839         @DefinedBy(Api.COMPILER_TREE)
 840         public List<JCTypeParameter> getTypeParameters() {
 841             return typarams;
 842         }
 843         @DefinedBy(Api.COMPILER_TREE)
 844         public JCExpression getExtendsClause() { return extending; }
 845         @DefinedBy(Api.COMPILER_TREE)
 846         public List<JCExpression> getImplementsClause() {
 847             return implementing;
 848         }
 849         @SuppressWarnings("removal")
 850         @DefinedBy(Api.COMPILER_TREE)
 851         public List<JCExpression> getPermitsClause() {
 852             return permitting;
 853         }
 854         @DefinedBy(Api.COMPILER_TREE)
 855         public List<JCTree> getMembers() {
 856             return defs;
 857         }
 858         @Override @DefinedBy(Api.COMPILER_TREE)
 859         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
 860             return v.visitClass(this, d);
 861         }
 862 
 863         @Override
 864         public Tag getTag() {
 865             return CLASSDEF;
 866         }
 867     }
 868 
 869     /**
 870      * A method definition.
 871      */
 872     public static class JCMethodDecl extends JCTree implements MethodTree {
 873         /** method modifiers */
 874         public JCModifiers mods;
 875         /** method name */
 876         public Name name;
 877         /** type of method return value */
 878         public JCExpression restype;
 879         /** type parameters */
 880         public List<JCTypeParameter> typarams;
 881         /** receiver parameter */
 882         public JCVariableDecl recvparam;
 883         /** value parameters */
 884         public List<JCVariableDecl> params;
 885         /** exceptions thrown by this method */
 886         public List<JCExpression> thrown;
 887         /** statements in the method */
 888         public JCBlock body;
 889         /** default value, for annotation types */
 890         public JCExpression defaultValue;
 891         /** method symbol */
 892         public MethodSymbol sym;



 893         /** does this method completes normally */
 894         public boolean completesNormally;
 895 
 896         protected JCMethodDecl(JCModifiers mods,
 897                             Name name,
 898                             JCExpression restype,
 899                             List<JCTypeParameter> typarams,
 900                             JCVariableDecl recvparam,
 901                             List<JCVariableDecl> params,
 902                             List<JCExpression> thrown,
 903                             JCBlock body,
 904                             JCExpression defaultValue,
 905                             MethodSymbol sym)
 906         {
 907             this.mods = mods;
 908             this.name = name;
 909             this.restype = restype;
 910             this.typarams = typarams;
 911             this.params = params;
 912             this.recvparam = recvparam;
 913             // TODO: do something special if the given type is null?
 914             // receiver != null ? receiver : List.<JCTypeAnnotation>nil());
 915             this.thrown = thrown;
 916             this.body = body;
 917             this.defaultValue = defaultValue;
 918             this.sym = sym;
 919         }
 920         @Override
 921         public void accept(Visitor v) { v.visitMethodDef(this); }
 922 
 923         @DefinedBy(Api.COMPILER_TREE)
 924         public Kind getKind() { return Kind.METHOD; }
 925         @DefinedBy(Api.COMPILER_TREE)
 926         public JCModifiers getModifiers() { return mods; }
 927         @DefinedBy(Api.COMPILER_TREE)
 928         public Name getName() { return name; }
 929         @DefinedBy(Api.COMPILER_TREE)
 930         public JCTree getReturnType() { return restype; }
 931         @DefinedBy(Api.COMPILER_TREE)
 932         public List<JCTypeParameter> getTypeParameters() {
 933             return typarams;
 934         }
 935         @DefinedBy(Api.COMPILER_TREE)
 936         public List<JCVariableDecl> getParameters() {
 937             return params;
 938         }
 939         @DefinedBy(Api.COMPILER_TREE)
 940         public JCVariableDecl getReceiverParameter() { return recvparam; }
 941         @DefinedBy(Api.COMPILER_TREE)
 942         public List<JCExpression> getThrows() {
 943             return thrown;
 944         }
 945         @DefinedBy(Api.COMPILER_TREE)
 946         public JCBlock getBody() { return body; }
 947         @DefinedBy(Api.COMPILER_TREE)
 948         public JCTree getDefaultValue() { // for annotation types
 949             return defaultValue;
 950         }
 951         @Override @DefinedBy(Api.COMPILER_TREE)
 952         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
 953             return v.visitMethod(this, d);
 954         }
 955 
 956         @Override
 957         public Tag getTag() {
 958             return METHODDEF;
 959         }
 960   }
 961 
 962     /**
 963      * A variable definition.
 964      */
 965     public static class JCVariableDecl extends JCStatement implements VariableTree {
 966         /** variable modifiers */
 967         public JCModifiers mods;
 968         /** variable name */
 969         public Name name;
 970         /** variable name expression */
 971         public JCExpression nameexpr;
 972         /** type of the variable */
 973         public JCExpression vartype;
 974         /** variable's initial value */
 975         public JCExpression init;
 976         /** symbol */
 977         public VarSymbol sym;
 978         /** explicit start pos */
 979         public int startPos = Position.NOPOS;
 980         /** declared using `var` */
 981         private boolean declaredUsingVar;
 982 
 983         protected JCVariableDecl(JCModifiers mods,
 984                          Name name,
 985                          JCExpression vartype,
 986                          JCExpression init,
 987                          VarSymbol sym) {
 988             this(mods, name, vartype, init, sym, false);
 989         }
 990 
 991         protected JCVariableDecl(JCModifiers mods,
 992                                  Name name,
 993                                  JCExpression vartype,
 994                                  JCExpression init,
 995                                  VarSymbol sym,
 996                                  boolean declaredUsingVar) {
 997             this.mods = mods;
 998             this.name = name;
 999             this.vartype = vartype;
1000             this.init = init;
1001             this.sym = sym;
1002             this.declaredUsingVar = declaredUsingVar;
1003         }
1004 
1005         protected JCVariableDecl(JCModifiers mods,
1006                          JCExpression nameexpr,
1007                          JCExpression vartype) {
1008             this(mods, null, vartype, null, null, false);
1009             this.nameexpr = nameexpr;
1010             if (nameexpr.hasTag(Tag.IDENT)) {
1011                 this.name = ((JCIdent)nameexpr).name;
1012             } else {
1013                 // Only other option is qualified name x.y.this;
1014                 this.name = ((JCFieldAccess)nameexpr).name;
1015             }
1016         }
1017 
1018         public boolean isImplicitlyTyped() {
1019             return vartype == null;
1020         }
1021 
1022         public boolean declaredUsingVar() {
1023             return declaredUsingVar;
1024         }
1025 
1026         @Override
1027         public void accept(Visitor v) { v.visitVarDef(this); }
1028 
1029         @DefinedBy(Api.COMPILER_TREE)
1030         public Kind getKind() { return Kind.VARIABLE; }
1031         @DefinedBy(Api.COMPILER_TREE)
1032         public JCModifiers getModifiers() { return mods; }
1033         @DefinedBy(Api.COMPILER_TREE)
1034         public Name getName() { return name; }
1035         @DefinedBy(Api.COMPILER_TREE)
1036         public JCExpression getNameExpression() { return nameexpr; }
1037         @DefinedBy(Api.COMPILER_TREE)
1038         public JCTree getType() { return vartype; }
1039         @DefinedBy(Api.COMPILER_TREE)
1040         public JCExpression getInitializer() {
1041             return init;
1042         }
1043         @Override @DefinedBy(Api.COMPILER_TREE)
1044         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1045             return v.visitVariable(this, d);
1046         }
1047 
1048         @Override
1049         public Tag getTag() {
1050             return VARDEF;
1051         }
1052     }
1053 
1054     /**
1055      * A no-op statement ";".
1056      */
1057     public static class JCSkip extends JCStatement implements EmptyStatementTree {
1058         protected JCSkip() {
1059         }
1060         @Override
1061         public void accept(Visitor v) { v.visitSkip(this); }
1062 
1063         @DefinedBy(Api.COMPILER_TREE)
1064         public Kind getKind() { return Kind.EMPTY_STATEMENT; }
1065         @Override @DefinedBy(Api.COMPILER_TREE)
1066         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1067             return v.visitEmptyStatement(this, d);
1068         }
1069 
1070         @Override
1071         public Tag getTag() {
1072             return SKIP;
1073         }
1074     }
1075 
1076     /**
1077      * A statement block.
1078      */
1079     public static class JCBlock extends JCStatement implements BlockTree {
1080         /** flags */
1081         public long flags;
1082         /** statements */
1083         public List<JCStatement> stats;
1084         /** Position of closing brace, optional. */
1085         public int endpos = Position.NOPOS;
1086         protected JCBlock(long flags, List<JCStatement> stats) {
1087             this.stats = stats;
1088             this.flags = flags;
1089         }
1090         @Override
1091         public void accept(Visitor v) { v.visitBlock(this); }
1092 
1093         @DefinedBy(Api.COMPILER_TREE)
1094         public Kind getKind() { return Kind.BLOCK; }
1095         @DefinedBy(Api.COMPILER_TREE)
1096         public List<JCStatement> getStatements() {
1097             return stats;
1098         }
1099         @DefinedBy(Api.COMPILER_TREE)
1100         public boolean isStatic() { return (flags & Flags.STATIC) != 0; }
1101         @Override @DefinedBy(Api.COMPILER_TREE)
1102         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1103             return v.visitBlock(this, d);
1104         }
1105 
1106         @Override
1107         public Tag getTag() {
1108             return BLOCK;
1109         }
1110     }
1111 
1112     /**
1113      * A do loop
1114      */
1115     public static class JCDoWhileLoop extends JCStatement implements DoWhileLoopTree {
1116         public JCStatement body;
1117         public JCExpression cond;
1118         protected JCDoWhileLoop(JCStatement body, JCExpression cond) {
1119             this.body = body;
1120             this.cond = cond;
1121         }
1122         @Override
1123         public void accept(Visitor v) { v.visitDoLoop(this); }
1124 
1125         @DefinedBy(Api.COMPILER_TREE)
1126         public Kind getKind() { return Kind.DO_WHILE_LOOP; }
1127         @DefinedBy(Api.COMPILER_TREE)
1128         public JCExpression getCondition() { return cond; }
1129         @DefinedBy(Api.COMPILER_TREE)
1130         public JCStatement getStatement() { return body; }
1131         @Override @DefinedBy(Api.COMPILER_TREE)
1132         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1133             return v.visitDoWhileLoop(this, d);
1134         }
1135 
1136         @Override
1137         public Tag getTag() {
1138             return DOLOOP;
1139         }
1140     }
1141 
1142     /**
1143      * A while loop
1144      */
1145     public static class JCWhileLoop extends JCStatement implements WhileLoopTree {
1146         public JCExpression cond;
1147         public JCStatement body;
1148         protected JCWhileLoop(JCExpression cond, JCStatement body) {
1149             this.cond = cond;
1150             this.body = body;
1151         }
1152         @Override
1153         public void accept(Visitor v) { v.visitWhileLoop(this); }
1154 
1155         @DefinedBy(Api.COMPILER_TREE)
1156         public Kind getKind() { return Kind.WHILE_LOOP; }
1157         @DefinedBy(Api.COMPILER_TREE)
1158         public JCExpression getCondition() { return cond; }
1159         @DefinedBy(Api.COMPILER_TREE)
1160         public JCStatement getStatement() { return body; }
1161         @Override @DefinedBy(Api.COMPILER_TREE)
1162         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1163             return v.visitWhileLoop(this, d);
1164         }
1165 
1166         @Override
1167         public Tag getTag() {
1168             return WHILELOOP;
1169         }
1170     }
1171 






























1172     /**
1173      * A for loop.
1174      */
1175     public static class JCForLoop extends JCStatement implements ForLoopTree {
1176         public List<JCStatement> init;
1177         public JCExpression cond;
1178         public List<JCExpressionStatement> step;
1179         public JCStatement body;
1180         protected JCForLoop(List<JCStatement> init,
1181                           JCExpression cond,
1182                           List<JCExpressionStatement> update,
1183                           JCStatement body)
1184         {
1185             this.init = init;
1186             this.cond = cond;
1187             this.step = update;
1188             this.body = body;
1189         }
1190         @Override
1191         public void accept(Visitor v) { v.visitForLoop(this); }
1192 
1193         @DefinedBy(Api.COMPILER_TREE)
1194         public Kind getKind() { return Kind.FOR_LOOP; }
1195         @DefinedBy(Api.COMPILER_TREE)
1196         public JCExpression getCondition() { return cond; }
1197         @DefinedBy(Api.COMPILER_TREE)
1198         public JCStatement getStatement() { return body; }
1199         @DefinedBy(Api.COMPILER_TREE)
1200         public List<JCStatement> getInitializer() {
1201             return init;
1202         }
1203         @DefinedBy(Api.COMPILER_TREE)
1204         public List<JCExpressionStatement> getUpdate() {
1205             return step;
1206         }
1207         @Override @DefinedBy(Api.COMPILER_TREE)
1208         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1209             return v.visitForLoop(this, d);
1210         }
1211 
1212         @Override
1213         public Tag getTag() {
1214             return FORLOOP;
1215         }
1216     }
1217 
1218     /**
1219      * The enhanced for loop.
1220      */
1221     public static class JCEnhancedForLoop extends JCStatement implements EnhancedForLoopTree {
1222         public JCVariableDecl var;
1223         public JCExpression expr;
1224         public JCStatement body;
1225         protected JCEnhancedForLoop(JCVariableDecl var, JCExpression expr, JCStatement body) {
1226             this.var = var;
1227             this.expr = expr;
1228             this.body = body;
1229         }
1230         @Override
1231         public void accept(Visitor v) { v.visitForeachLoop(this); }
1232 
1233         @DefinedBy(Api.COMPILER_TREE)
1234         public Kind getKind() { return Kind.ENHANCED_FOR_LOOP; }
1235         @DefinedBy(Api.COMPILER_TREE)
1236         public JCVariableDecl getVariable() { return var; }
1237         @DefinedBy(Api.COMPILER_TREE)
1238         public JCExpression getExpression() { return expr; }
1239         @DefinedBy(Api.COMPILER_TREE)
1240         public JCStatement getStatement() { return body; }
1241         @Override @DefinedBy(Api.COMPILER_TREE)
1242         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1243             return v.visitEnhancedForLoop(this, d);
1244         }
1245         @Override
1246         public Tag getTag() {
1247             return FOREACHLOOP;
1248         }
1249     }
1250 
1251     /**
1252      * A labelled expression or statement.
1253      */
1254     public static class JCLabeledStatement extends JCStatement implements LabeledStatementTree {
1255         public Name label;
1256         public JCStatement body;
1257         protected JCLabeledStatement(Name label, JCStatement body) {
1258             this.label = label;
1259             this.body = body;
1260         }
1261         @Override
1262         public void accept(Visitor v) { v.visitLabelled(this); }
1263         @DefinedBy(Api.COMPILER_TREE)
1264         public Kind getKind() { return Kind.LABELED_STATEMENT; }
1265         @DefinedBy(Api.COMPILER_TREE)
1266         public Name getLabel() { return label; }
1267         @DefinedBy(Api.COMPILER_TREE)
1268         public JCStatement getStatement() { return body; }
1269         @Override @DefinedBy(Api.COMPILER_TREE)
1270         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1271             return v.visitLabeledStatement(this, d);
1272         }
1273         @Override
1274         public Tag getTag() {
1275             return LABELLED;
1276         }
1277     }
1278 
1279     /**
1280      * A "switch ( ) { }" construction.
1281      */
1282     public static class JCSwitch extends JCStatement implements SwitchTree {
1283         public JCExpression selector;
1284         public List<JCCase> cases;
1285         /** Position of closing brace, optional. */
1286         public int endpos = Position.NOPOS;
1287         public boolean hasTotalPattern;
1288         public boolean isExhaustive;
1289         public boolean patternSwitch;
1290         protected JCSwitch(JCExpression selector, List<JCCase> cases) {
1291             this.selector = selector;
1292             this.cases = cases;
1293         }
1294         @Override
1295         public void accept(Visitor v) { v.visitSwitch(this); }
1296 
1297         @DefinedBy(Api.COMPILER_TREE)
1298         public Kind getKind() { return Kind.SWITCH; }
1299         @DefinedBy(Api.COMPILER_TREE)
1300         public JCExpression getExpression() { return selector; }
1301         @DefinedBy(Api.COMPILER_TREE)
1302         public List<JCCase> getCases() { return cases; }
1303         @Override @DefinedBy(Api.COMPILER_TREE)
1304         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1305             return v.visitSwitch(this, d);
1306         }
1307         @Override
1308         public Tag getTag() {
1309             return SWITCH;
1310         }
1311     }
1312 
1313     /**
1314      * A "case  :" of a switch.
1315      */
1316     public static class JCCase extends JCStatement implements CaseTree {
1317         //as CaseKind is deprecated for removal (as it is part of a preview feature),
1318         //using indirection through these fields to avoid unnecessary @SuppressWarnings:
1319         public static final CaseKind STATEMENT = CaseKind.STATEMENT;
1320         public static final CaseKind RULE = CaseKind.RULE;
1321         public final CaseKind caseKind;
1322         public List<JCCaseLabel> labels;
1323         public List<JCStatement> stats;
1324         public JCTree body;
1325         public boolean completesNormally;
1326         protected JCCase(CaseKind caseKind, List<JCCaseLabel> labels,
1327                          List<JCStatement> stats, JCTree body) {
1328             Assert.checkNonNull(labels);
1329             Assert.check(labels.isEmpty() || labels.head != null);
1330             this.caseKind = caseKind;
1331             this.labels = labels;
1332             this.stats = stats;
1333             this.body = body;
1334         }
1335         @Override
1336         public void accept(Visitor v) { v.visitCase(this); }
1337 
1338         @Override @DefinedBy(Api.COMPILER_TREE)
1339         public Kind getKind() { return Kind.CASE; }
1340         @Override @Deprecated @DefinedBy(Api.COMPILER_TREE)
1341         public JCExpression getExpression() { return getExpressions().head; }
1342         @Override @DefinedBy(Api.COMPILER_TREE)
1343         public List<JCExpression> getExpressions() { return labels.stream().filter(p -> p instanceof JCExpression).map(p -> (JCExpression) p).collect(List.collector()); }
1344         @Override @DefinedBy(Api.COMPILER_TREE)
1345         public List<JCCaseLabel> getLabels() { return labels; }
1346         @Override @DefinedBy(Api.COMPILER_TREE)
1347         public List<JCStatement> getStatements() {
1348             return caseKind == CaseKind.STATEMENT ? stats : null;
1349         }
1350         @Override @DefinedBy(Api.COMPILER_TREE)
1351         public JCTree getBody() { return body; }
1352         @Override @DefinedBy(Api.COMPILER_TREE)
1353         public CaseKind getCaseKind() {
1354             return caseKind;
1355         }
1356         @Override @DefinedBy(Api.COMPILER_TREE)
1357         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1358             return v.visitCase(this, d);
1359         }
1360         @Override
1361         public Tag getTag() {
1362             return CASE;
1363         }
1364     }
1365 


























1366     /**
1367      * A "switch ( ) { }" construction.
1368      */
1369     public static class JCSwitchExpression extends JCPolyExpression implements SwitchExpressionTree {
1370         public JCExpression selector;
1371         public List<JCCase> cases;
1372         /** Position of closing brace, optional. */
1373         public int endpos = Position.NOPOS;
1374         public boolean hasTotalPattern;
1375         public boolean isExhaustive;
1376         public boolean patternSwitch;
1377         protected JCSwitchExpression(JCExpression selector, List<JCCase> cases) {
1378             this.selector = selector;
1379             this.cases = cases;
1380         }
1381         @Override
1382         public void accept(Visitor v) { v.visitSwitchExpression(this); }
1383 
1384         @DefinedBy(Api.COMPILER_TREE)
1385         public Kind getKind() { return Kind.SWITCH_EXPRESSION; }
1386         @DefinedBy(Api.COMPILER_TREE)
1387         public JCExpression getExpression() { return selector; }
1388         @DefinedBy(Api.COMPILER_TREE)
1389         public List<JCCase> getCases() { return cases; }
1390         @Override @DefinedBy(Api.COMPILER_TREE)
1391         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1392             return v.visitSwitchExpression(this, d);
1393         }
1394         @Override
1395         public Tag getTag() {
1396             return SWITCH_EXPRESSION;
1397         }
1398     }
1399 
1400     /**
1401      * A synchronized block.
1402      */
1403     public static class JCSynchronized extends JCStatement implements SynchronizedTree {
1404         public JCExpression lock;
1405         public JCBlock body;
1406         protected JCSynchronized(JCExpression lock, JCBlock body) {
1407             this.lock = lock;
1408             this.body = body;
1409         }
1410         @Override
1411         public void accept(Visitor v) { v.visitSynchronized(this); }
1412 
1413         @DefinedBy(Api.COMPILER_TREE)
1414         public Kind getKind() { return Kind.SYNCHRONIZED; }
1415         @DefinedBy(Api.COMPILER_TREE)
1416         public JCExpression getExpression() { return lock; }
1417         @DefinedBy(Api.COMPILER_TREE)
1418         public JCBlock getBlock() { return body; }
1419         @Override @DefinedBy(Api.COMPILER_TREE)
1420         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1421             return v.visitSynchronized(this, d);
1422         }
1423         @Override
1424         public Tag getTag() {
1425             return SYNCHRONIZED;
1426         }
1427     }
1428 
1429     /**
1430      * A "try { } catch ( ) { } finally { }" block.
1431      */
1432     public static class JCTry extends JCStatement implements TryTree {
1433         public JCBlock body;
1434         public List<JCCatch> catchers;
1435         public JCBlock finalizer;
1436         public List<JCTree> resources;
1437         public boolean finallyCanCompleteNormally;
1438         protected JCTry(List<JCTree> resources,
1439                         JCBlock body,
1440                         List<JCCatch> catchers,
1441                         JCBlock finalizer) {
1442             this.body = body;
1443             this.catchers = catchers;
1444             this.finalizer = finalizer;
1445             this.resources = resources;
1446         }
1447         @Override
1448         public void accept(Visitor v) { v.visitTry(this); }
1449 
1450         @DefinedBy(Api.COMPILER_TREE)
1451         public Kind getKind() { return Kind.TRY; }
1452         @DefinedBy(Api.COMPILER_TREE)
1453         public JCBlock getBlock() { return body; }
1454         @DefinedBy(Api.COMPILER_TREE)
1455         public List<JCCatch> getCatches() {
1456             return catchers;
1457         }
1458         @DefinedBy(Api.COMPILER_TREE)
1459         public JCBlock getFinallyBlock() { return finalizer; }
1460         @Override @DefinedBy(Api.COMPILER_TREE)
1461         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1462             return v.visitTry(this, d);
1463         }
1464         @Override @DefinedBy(Api.COMPILER_TREE)
1465         public List<JCTree> getResources() {
1466             return resources;
1467         }
1468         @Override
1469         public Tag getTag() {
1470             return TRY;
1471         }
1472     }
1473 
1474     /**
1475      * A catch block.
1476      */
1477     public static class JCCatch extends JCTree implements CatchTree {
1478         public JCVariableDecl param;
1479         public JCBlock body;
1480         protected JCCatch(JCVariableDecl param, JCBlock body) {
1481             this.param = param;
1482             this.body = body;
1483         }
1484         @Override
1485         public void accept(Visitor v) { v.visitCatch(this); }
1486 
1487         @DefinedBy(Api.COMPILER_TREE)
1488         public Kind getKind() { return Kind.CATCH; }
1489         @DefinedBy(Api.COMPILER_TREE)
1490         public JCVariableDecl getParameter() { return param; }
1491         @DefinedBy(Api.COMPILER_TREE)
1492         public JCBlock getBlock() { return body; }
1493         @Override @DefinedBy(Api.COMPILER_TREE)
1494         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1495             return v.visitCatch(this, d);
1496         }
1497         @Override
1498         public Tag getTag() {
1499             return CATCH;
1500         }
1501     }
1502 
1503     /**
1504      * A ( ) ? ( ) : ( ) conditional expression
1505      */
1506     public static class JCConditional extends JCPolyExpression implements ConditionalExpressionTree {
1507         public JCExpression cond;
1508         public JCExpression truepart;
1509         public JCExpression falsepart;
1510         protected JCConditional(JCExpression cond,
1511                               JCExpression truepart,
1512                               JCExpression falsepart)
1513         {
1514             this.cond = cond;
1515             this.truepart = truepart;
1516             this.falsepart = falsepart;
1517         }
1518         @Override
1519         public void accept(Visitor v) { v.visitConditional(this); }
1520 
1521         @DefinedBy(Api.COMPILER_TREE)
1522         public Kind getKind() { return Kind.CONDITIONAL_EXPRESSION; }
1523         @DefinedBy(Api.COMPILER_TREE)
1524         public JCExpression getCondition() { return cond; }
1525         @DefinedBy(Api.COMPILER_TREE)
1526         public JCExpression getTrueExpression() { return truepart; }
1527         @DefinedBy(Api.COMPILER_TREE)
1528         public JCExpression getFalseExpression() { return falsepart; }
1529         @Override @DefinedBy(Api.COMPILER_TREE)
1530         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1531             return v.visitConditionalExpression(this, d);
1532         }
1533         @Override
1534         public Tag getTag() {
1535             return CONDEXPR;
1536         }
1537     }
1538 
1539     /**
1540      * An "if ( ) { } else { }" block
1541      */
1542     public static class JCIf extends JCStatement implements IfTree {
1543         public JCExpression cond;
1544         public JCStatement thenpart;
1545         public JCStatement elsepart;
1546         protected JCIf(JCExpression cond,
1547                      JCStatement thenpart,
1548                      JCStatement elsepart)
1549         {
1550             this.cond = cond;
1551             this.thenpart = thenpart;
1552             this.elsepart = elsepart;
1553         }
1554         @Override
1555         public void accept(Visitor v) { v.visitIf(this); }
1556 
1557         @DefinedBy(Api.COMPILER_TREE)
1558         public Kind getKind() { return Kind.IF; }
1559         @DefinedBy(Api.COMPILER_TREE)
1560         public JCExpression getCondition() { return cond; }
1561         @DefinedBy(Api.COMPILER_TREE)
1562         public JCStatement getThenStatement() { return thenpart; }
1563         @DefinedBy(Api.COMPILER_TREE)
1564         public JCStatement getElseStatement() { return elsepart; }
1565         @Override @DefinedBy(Api.COMPILER_TREE)
1566         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1567             return v.visitIf(this, d);
1568         }
1569         @Override
1570         public Tag getTag() {
1571             return IF;
1572         }
1573     }
1574 
1575     /**
1576      * an expression statement
1577      */
1578     public static class JCExpressionStatement extends JCStatement implements ExpressionStatementTree {
1579         /** expression structure */
1580         public JCExpression expr;
1581         protected JCExpressionStatement(JCExpression expr)
1582         {
1583             this.expr = expr;
1584         }
1585         @Override
1586         public void accept(Visitor v) { v.visitExec(this); }
1587 
1588         @DefinedBy(Api.COMPILER_TREE)
1589         public Kind getKind() { return Kind.EXPRESSION_STATEMENT; }
1590         @DefinedBy(Api.COMPILER_TREE)
1591         public JCExpression getExpression() { return expr; }
1592         @Override @DefinedBy(Api.COMPILER_TREE)
1593         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1594             return v.visitExpressionStatement(this, d);
1595         }
1596         @Override
1597         public Tag getTag() {
1598             return EXEC;
1599         }
1600 
1601         /** Convert a expression-statement tree to a pretty-printed string. */
1602         @Override
1603         public String toString() {
1604             StringWriter s = new StringWriter();
1605             try {
1606                 new Pretty(s, false).printStat(this);
1607             }
1608             catch (IOException e) {
1609                 // should never happen, because StringWriter is defined
1610                 // never to throw any IOExceptions
1611                 throw new AssertionError(e);
1612             }
1613             return s.toString();
1614         }
1615     }
1616 
1617     /**
1618      * A break from a loop or switch.
1619      */
1620     public static class JCBreak extends JCStatement implements BreakTree {
1621         public Name label;
1622         public JCTree target;
1623         protected JCBreak(Name label, JCTree target) {
1624             this.label = label;
1625             this.target = target;
1626         }
1627         @Override
1628         public void accept(Visitor v) { v.visitBreak(this); }
1629         public boolean isValueBreak() {
1630             return target != null && target.hasTag(SWITCH_EXPRESSION);
1631         }
1632 
1633         @DefinedBy(Api.COMPILER_TREE)
1634         public Kind getKind() { return Kind.BREAK; }
1635         @DefinedBy(Api.COMPILER_TREE)
1636         public Name getLabel() {
1637             return label;
1638         }
1639         @Override @DefinedBy(Api.COMPILER_TREE)
1640         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1641             return v.visitBreak(this, d);
1642         }
1643         @Override
1644         public Tag getTag() {
1645             return BREAK;
1646         }
1647     }
1648 
1649     /**
1650      * A break-with from a switch expression.
1651      */
1652     public static class JCYield extends JCStatement implements YieldTree {
1653         public JCExpression value;
1654         public JCTree target;
1655         protected JCYield(JCExpression value, JCTree target) {
1656             this.value = value;
1657             this.target = target;
1658         }
1659         @Override
1660         public void accept(Visitor v) { v.visitYield(this); }
1661         @DefinedBy(Api.COMPILER_TREE)
1662         public Kind getKind() { return Kind.YIELD; }
1663         @DefinedBy(Api.COMPILER_TREE)
1664         public JCExpression getValue() { return value; }
1665         @Override @DefinedBy(Api.COMPILER_TREE)
1666         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1667             return v.visitYield(this, d);
1668         }
1669         @Override
1670         public Tag getTag() {
1671             return YIELD;
1672         }
1673     }
1674 
1675     /**
1676      * A continue of a loop.
1677      */
1678     public static class JCContinue extends JCStatement implements ContinueTree {
1679         public Name label;
1680         public JCTree target;
1681         protected JCContinue(Name label, JCTree target) {
1682             this.label = label;
1683             this.target = target;
1684         }
1685         @Override
1686         public void accept(Visitor v) { v.visitContinue(this); }
1687 
1688         @DefinedBy(Api.COMPILER_TREE)
1689         public Kind getKind() { return Kind.CONTINUE; }
1690         @DefinedBy(Api.COMPILER_TREE)
1691         public Name getLabel() { return label; }
1692         @Override @DefinedBy(Api.COMPILER_TREE)
1693         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1694             return v.visitContinue(this, d);
1695         }
1696         @Override
1697         public Tag getTag() {
1698             return CONTINUE;
1699         }
1700     }
1701 
1702     /**
1703      * A return statement.
1704      */
1705     public static class JCReturn extends JCStatement implements ReturnTree {
1706         public JCExpression expr;
1707         protected JCReturn(JCExpression expr) {
1708             this.expr = expr;
1709         }
1710         @Override
1711         public void accept(Visitor v) { v.visitReturn(this); }
1712 
1713         @DefinedBy(Api.COMPILER_TREE)
1714         public Kind getKind() { return Kind.RETURN; }
1715         @DefinedBy(Api.COMPILER_TREE)
1716         public JCExpression getExpression() { return expr; }
1717         @Override @DefinedBy(Api.COMPILER_TREE)
1718         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1719             return v.visitReturn(this, d);
1720         }
1721         @Override
1722         public Tag getTag() {
1723             return RETURN;
1724         }
1725     }
1726 
1727     /**
1728      * A throw statement.
1729      */
1730     public static class JCThrow extends JCStatement implements ThrowTree {
1731         public JCExpression expr;
1732         protected JCThrow(JCExpression expr) {
1733             this.expr = expr;
1734         }
1735         @Override
1736         public void accept(Visitor v) { v.visitThrow(this); }
1737 
1738         @DefinedBy(Api.COMPILER_TREE)
1739         public Kind getKind() { return Kind.THROW; }
1740         @DefinedBy(Api.COMPILER_TREE)
1741         public JCExpression getExpression() { return expr; }
1742         @Override @DefinedBy(Api.COMPILER_TREE)
1743         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1744             return v.visitThrow(this, d);
1745         }
1746         @Override
1747         public Tag getTag() {
1748             return THROW;
1749         }
1750     }
1751 
1752     /**
1753      * An assert statement.
1754      */
1755     public static class JCAssert extends JCStatement implements AssertTree {
1756         public JCExpression cond;
1757         public JCExpression detail;
1758         protected JCAssert(JCExpression cond, JCExpression detail) {
1759             this.cond = cond;
1760             this.detail = detail;
1761         }
1762         @Override
1763         public void accept(Visitor v) { v.visitAssert(this); }
1764 
1765         @DefinedBy(Api.COMPILER_TREE)
1766         public Kind getKind() { return Kind.ASSERT; }
1767         @DefinedBy(Api.COMPILER_TREE)
1768         public JCExpression getCondition() { return cond; }
1769         @DefinedBy(Api.COMPILER_TREE)
1770         public JCExpression getDetail() { return detail; }
1771         @Override @DefinedBy(Api.COMPILER_TREE)
1772         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1773             return v.visitAssert(this, d);
1774         }
1775         @Override
1776         public Tag getTag() {
1777             return ASSERT;
1778         }
1779     }
1780 
1781     /**
1782      * A method invocation
1783      */
1784     public static class JCMethodInvocation extends JCPolyExpression implements MethodInvocationTree {
1785         public List<JCExpression> typeargs;
1786         public JCExpression meth;
1787         public List<JCExpression> args;
1788         public Type varargsElement;
1789         protected JCMethodInvocation(List<JCExpression> typeargs,
1790                         JCExpression meth,
1791                         List<JCExpression> args)
1792         {
1793             this.typeargs = (typeargs == null) ? List.nil()
1794                                                : typeargs;
1795             this.meth = meth;
1796             this.args = args;
1797         }
1798         @Override
1799         public void accept(Visitor v) { v.visitApply(this); }
1800 
1801         @DefinedBy(Api.COMPILER_TREE)
1802         public Kind getKind() { return Kind.METHOD_INVOCATION; }
1803         @DefinedBy(Api.COMPILER_TREE)
1804         public List<JCExpression> getTypeArguments() {
1805             return typeargs;
1806         }
1807         @DefinedBy(Api.COMPILER_TREE)
1808         public JCExpression getMethodSelect() { return meth; }
1809         @DefinedBy(Api.COMPILER_TREE)
1810         public List<JCExpression> getArguments() {
1811             return args;
1812         }
1813         @Override @DefinedBy(Api.COMPILER_TREE)
1814         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1815             return v.visitMethodInvocation(this, d);
1816         }
1817         @Override
1818         public JCMethodInvocation setType(Type type) {
1819             super.setType(type);
1820             return this;
1821         }
1822         @Override
1823         public Tag getTag() {
1824             return(APPLY);
1825         }
1826     }
1827 
1828     /**
1829      * A new(...) operation.
1830      */
1831     public static class JCNewClass extends JCPolyExpression implements NewClassTree {
1832         public JCExpression encl;
1833         public List<JCExpression> typeargs;
1834         public JCExpression clazz;
1835         public List<JCExpression> args;
1836         public JCClassDecl def;
1837         public Symbol constructor;
1838         public Type varargsElement;
1839         public Type constructorType;
1840         protected JCNewClass(JCExpression encl,
1841                            List<JCExpression> typeargs,
1842                            JCExpression clazz,
1843                            List<JCExpression> args,
1844                            JCClassDecl def)
1845         {
1846             this.encl = encl;
1847             this.typeargs = (typeargs == null) ? List.nil()
1848                                                : typeargs;
1849             this.clazz = clazz;
1850             this.args = args;
1851             this.def = def;
1852         }
1853         @Override
1854         public void accept(Visitor v) { v.visitNewClass(this); }
1855 
1856         @DefinedBy(Api.COMPILER_TREE)
1857         public Kind getKind() { return Kind.NEW_CLASS; }
1858         @DefinedBy(Api.COMPILER_TREE)
1859         public JCExpression getEnclosingExpression() { // expr.new C< ... > ( ... )
1860             return encl;
1861         }
1862         @DefinedBy(Api.COMPILER_TREE)
1863         public List<JCExpression> getTypeArguments() {
1864             return typeargs;
1865         }
1866         @DefinedBy(Api.COMPILER_TREE)
1867         public JCExpression getIdentifier() { return clazz; }
1868         @DefinedBy(Api.COMPILER_TREE)
1869         public List<JCExpression> getArguments() {
1870             return args;
1871         }
1872         @DefinedBy(Api.COMPILER_TREE)
1873         public JCClassDecl getClassBody() { return def; }
1874         @Override @DefinedBy(Api.COMPILER_TREE)
1875         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1876             return v.visitNewClass(this, d);
1877         }
1878         @Override
1879         public Tag getTag() {
1880             return NEWCLASS;
1881         }
1882 
1883         public boolean classDeclRemoved() {
1884             return false;
1885         }
1886     }
1887 
1888     /**
1889      * A new[...] operation.
1890      */
1891     public static class JCNewArray extends JCExpression implements NewArrayTree {
1892         public JCExpression elemtype;
1893         public List<JCExpression> dims;
1894         // type annotations on inner-most component
1895         public List<JCAnnotation> annotations;
1896         // type annotations on dimensions
1897         public List<List<JCAnnotation>> dimAnnotations;
1898         public List<JCExpression> elems;
1899         protected JCNewArray(JCExpression elemtype,
1900                            List<JCExpression> dims,
1901                            List<JCExpression> elems)
1902         {
1903             this.elemtype = elemtype;
1904             this.dims = dims;
1905             this.annotations = List.nil();
1906             this.dimAnnotations = List.nil();
1907             this.elems = elems;
1908         }
1909         @Override
1910         public void accept(Visitor v) { v.visitNewArray(this); }
1911 
1912         @DefinedBy(Api.COMPILER_TREE)
1913         public Kind getKind() { return Kind.NEW_ARRAY; }
1914         @DefinedBy(Api.COMPILER_TREE)
1915         public JCExpression getType() { return elemtype; }
1916         @DefinedBy(Api.COMPILER_TREE)
1917         public List<JCExpression> getDimensions() {
1918             return dims;
1919         }
1920         @DefinedBy(Api.COMPILER_TREE)
1921         public List<JCExpression> getInitializers() {
1922             return elems;
1923         }
1924         @Override @DefinedBy(Api.COMPILER_TREE)
1925         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1926             return v.visitNewArray(this, d);
1927         }
1928         @Override
1929         public Tag getTag() {
1930             return NEWARRAY;
1931         }
1932 
1933         @Override @DefinedBy(Api.COMPILER_TREE)
1934         public List<JCAnnotation> getAnnotations() {
1935             return annotations;
1936         }
1937 
1938         @Override @DefinedBy(Api.COMPILER_TREE)
1939         public List<List<JCAnnotation>> getDimAnnotations() {
1940             return dimAnnotations;
1941         }
1942     }
1943 
1944     /**
1945      * A lambda expression.
1946      */
1947     public static class JCLambda extends JCFunctionalExpression implements LambdaExpressionTree {
1948 
1949         public enum ParameterKind {
1950             IMPLICIT,
1951             EXPLICIT
1952         }
1953 
1954         public List<JCVariableDecl> params;
1955         public JCTree body;
1956         public boolean canCompleteNormally = true;
1957         public ParameterKind paramKind;
1958 
1959         public JCLambda(List<JCVariableDecl> params,
1960                         JCTree body) {
1961             this.params = params;
1962             this.body = body;
1963             if (params.isEmpty() ||
1964                 params.head.vartype != null) {
1965                 paramKind = ParameterKind.EXPLICIT;
1966             } else {
1967                 paramKind = ParameterKind.IMPLICIT;
1968             }
1969         }
1970         @Override
1971         public Tag getTag() {
1972             return LAMBDA;
1973         }
1974         @Override
1975         public void accept(Visitor v) {
1976             v.visitLambda(this);
1977         }
1978         @Override @DefinedBy(Api.COMPILER_TREE)
1979         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
1980             return v.visitLambdaExpression(this, d);
1981         }
1982         @DefinedBy(Api.COMPILER_TREE)
1983         public Kind getKind() {
1984             return Kind.LAMBDA_EXPRESSION;
1985         }
1986         @DefinedBy(Api.COMPILER_TREE)
1987         public JCTree getBody() {
1988             return body;
1989         }
1990         @DefinedBy(Api.COMPILER_TREE)
1991         public java.util.List<? extends VariableTree> getParameters() {
1992             return params;
1993         }
1994         @Override
1995         public JCLambda setType(Type type) {
1996             super.setType(type);
1997             return this;
1998         }
1999         @Override @DefinedBy(Api.COMPILER_TREE)
2000         public BodyKind getBodyKind() {
2001             return body.hasTag(BLOCK) ?
2002                     BodyKind.STATEMENT :
2003                     BodyKind.EXPRESSION;
2004         }
2005     }
2006 
2007     /**
2008      * A parenthesized subexpression ( ... )
2009      */
2010     public static class JCParens extends JCExpression implements ParenthesizedTree {
2011         public JCExpression expr;
2012         protected JCParens(JCExpression expr) {
2013             this.expr = expr;
2014         }
2015         @Override
2016         public void accept(Visitor v) { v.visitParens(this); }
2017 
2018         @DefinedBy(Api.COMPILER_TREE)
2019         public Kind getKind() { return Kind.PARENTHESIZED; }
2020         @DefinedBy(Api.COMPILER_TREE)
2021         public JCExpression getExpression() { return expr; }
2022         @Override @DefinedBy(Api.COMPILER_TREE)
2023         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2024             return v.visitParenthesized(this, d);
2025         }
2026         @Override
2027         public Tag getTag() {
2028             return PARENS;
2029         }
2030     }
2031 
2032     /**
2033      * A assignment with "=".
2034      */
2035     public static class JCAssign extends JCExpression implements AssignmentTree {
2036         public JCExpression lhs;
2037         public JCExpression rhs;
2038         protected JCAssign(JCExpression lhs, JCExpression rhs) {
2039             this.lhs = lhs;
2040             this.rhs = rhs;
2041         }
2042         @Override
2043         public void accept(Visitor v) { v.visitAssign(this); }
2044 
2045         @DefinedBy(Api.COMPILER_TREE)
2046         public Kind getKind() { return Kind.ASSIGNMENT; }
2047         @DefinedBy(Api.COMPILER_TREE)
2048         public JCExpression getVariable() { return lhs; }
2049         @DefinedBy(Api.COMPILER_TREE)
2050         public JCExpression getExpression() { return rhs; }
2051         @Override @DefinedBy(Api.COMPILER_TREE)
2052         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2053             return v.visitAssignment(this, d);
2054         }
2055         @Override
2056         public Tag getTag() {
2057             return ASSIGN;
2058         }
2059     }
2060 
2061     public abstract static class JCOperatorExpression extends JCExpression {
2062         public enum OperandPos {
2063             LEFT,
2064             RIGHT
2065         }
2066 
2067         protected Tag opcode;
2068         public OperatorSymbol operator;
2069 
2070         public OperatorSymbol getOperator() {
2071             return operator;
2072         }
2073 
2074         @Override
2075         public Tag getTag() {
2076             return opcode;
2077         }
2078 
2079         public abstract JCExpression getOperand(OperandPos pos);
2080     }
2081 
2082     /**
2083      * An assignment with "+=", "|=" ...
2084      */
2085     public static class JCAssignOp extends JCOperatorExpression implements CompoundAssignmentTree {
2086         public JCExpression lhs;
2087         public JCExpression rhs;
2088         protected JCAssignOp(Tag opcode, JCTree lhs, JCTree rhs, OperatorSymbol operator) {
2089             this.opcode = opcode;
2090             this.lhs = (JCExpression)lhs;
2091             this.rhs = (JCExpression)rhs;
2092             this.operator = operator;
2093         }
2094         @Override
2095         public void accept(Visitor v) { v.visitAssignop(this); }
2096 
2097         @DefinedBy(Api.COMPILER_TREE)
2098         public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
2099         @DefinedBy(Api.COMPILER_TREE)
2100         public JCExpression getVariable() { return lhs; }
2101         @DefinedBy(Api.COMPILER_TREE)
2102         public JCExpression getExpression() { return rhs; }
2103         @Override @DefinedBy(Api.COMPILER_TREE)
2104         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2105             return v.visitCompoundAssignment(this, d);
2106         }
2107         @Override
2108         public JCExpression getOperand(OperandPos pos) {
2109             return pos == OperandPos.LEFT ? lhs : rhs;
2110         }
2111     }
2112 
2113     /**
2114      * A unary operation.
2115      */
2116     public static class JCUnary extends JCOperatorExpression implements UnaryTree {
2117         public JCExpression arg;
2118         protected JCUnary(Tag opcode, JCExpression arg) {
2119             this.opcode = opcode;
2120             this.arg = arg;
2121         }
2122         @Override
2123         public void accept(Visitor v) { v.visitUnary(this); }
2124 
2125         @DefinedBy(Api.COMPILER_TREE)
2126         public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
2127         @DefinedBy(Api.COMPILER_TREE)
2128         public JCExpression getExpression() { return arg; }
2129         @Override @DefinedBy(Api.COMPILER_TREE)
2130         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2131             return v.visitUnary(this, d);
2132         }
2133         public void setTag(Tag tag) {
2134             opcode = tag;
2135         }
2136         @Override
2137         public JCExpression getOperand(OperandPos pos) {
2138             return arg;
2139         }
2140     }
2141 
2142     /**
2143      * A binary operation.
2144      */
2145     public static class JCBinary extends JCOperatorExpression implements BinaryTree {
2146         public JCExpression lhs;
2147         public JCExpression rhs;
2148         protected JCBinary(Tag opcode,
2149                          JCExpression lhs,
2150                          JCExpression rhs,
2151                          OperatorSymbol operator) {
2152             this.opcode = opcode;
2153             this.lhs = lhs;
2154             this.rhs = rhs;
2155             this.operator = operator;
2156         }
2157         @Override
2158         public void accept(Visitor v) { v.visitBinary(this); }
2159 
2160         @DefinedBy(Api.COMPILER_TREE)
2161         public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
2162         @DefinedBy(Api.COMPILER_TREE)
2163         public JCExpression getLeftOperand() { return lhs; }
2164         @DefinedBy(Api.COMPILER_TREE)
2165         public JCExpression getRightOperand() { return rhs; }
2166         @Override @DefinedBy(Api.COMPILER_TREE)
2167         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2168             return v.visitBinary(this, d);
2169         }
2170         @Override
2171         public JCExpression getOperand(OperandPos pos) {
2172             return pos == OperandPos.LEFT ? lhs : rhs;
2173         }
2174     }
2175 
2176     /**
2177      * A type cast.
2178      */
2179     public static class JCTypeCast extends JCExpression implements TypeCastTree {
2180         public JCTree clazz;
2181         public JCExpression expr;
2182         protected JCTypeCast(JCTree clazz, JCExpression expr) {
2183             this.clazz = clazz;
2184             this.expr = expr;
2185         }
2186         @Override
2187         public void accept(Visitor v) { v.visitTypeCast(this); }
2188 
2189         @DefinedBy(Api.COMPILER_TREE)
2190         public Kind getKind() { return Kind.TYPE_CAST; }
2191         @DefinedBy(Api.COMPILER_TREE)
2192         public JCTree getType() { return clazz; }
2193         @DefinedBy(Api.COMPILER_TREE)
2194         public JCExpression getExpression() { return expr; }
2195         @Override @DefinedBy(Api.COMPILER_TREE)
2196         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2197             return v.visitTypeCast(this, d);
2198         }
2199         @Override
2200         public Tag getTag() {
2201             return TYPECAST;
2202         }
2203     }
2204 
2205     /**
2206      * A type test.
2207      */
2208     public static class JCInstanceOf extends JCExpression implements InstanceOfTree {
2209         public JCExpression expr;
2210         public JCTree pattern;
2211         protected JCInstanceOf(JCExpression expr, JCTree pattern) {
2212             this.expr = expr;
2213             this.pattern = pattern;
2214         }
2215         @Override
2216         public void accept(Visitor v) { v.visitTypeTest(this); }
2217 
2218         @DefinedBy(Api.COMPILER_TREE)
2219         public Kind getKind() { return Kind.INSTANCE_OF; }
2220         @DefinedBy(Api.COMPILER_TREE)
2221         public JCTree getType() { return pattern instanceof JCPattern ? pattern.hasTag(BINDINGPATTERN) ? ((JCBindingPattern) pattern).var.vartype : null : pattern; }
2222 
2223         @Override @DefinedBy(Api.COMPILER_TREE)
2224         public JCPattern getPattern() {
2225             return pattern instanceof JCPattern jcPattern ? jcPattern : null;
2226         }
2227 
2228         @DefinedBy(Api.COMPILER_TREE)
2229         public JCExpression getExpression() { return expr; }
2230         @Override @DefinedBy(Api.COMPILER_TREE)
2231         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2232             return v.visitInstanceOf(this, d);
2233         }
2234         @Override
2235         public Tag getTag() {
2236             return TYPETEST;
2237         }
2238     }
2239 
2240     /**
2241      * Pattern matching forms.
2242      */
2243     public abstract static class JCPattern extends JCCaseLabel
2244             implements PatternTree {
2245 
2246         @Override
2247         public boolean isExpression() {
2248             return false;
2249         }
2250 
2251         @Override
2252         public boolean isPattern() {
2253             return true;
2254         }
2255     }
2256 
2257     public static class JCBindingPattern extends JCPattern
2258             implements BindingPatternTree {
2259         public JCVariableDecl var;
2260 
2261         protected JCBindingPattern(JCVariableDecl var) {
2262             this.var = var;
2263         }
2264 
2265         @Override @DefinedBy(Api.COMPILER_TREE)
2266         public VariableTree getVariable() {
2267             return var;
2268         }
2269 
2270         @Override
2271         public void accept(Visitor v) {
2272             v.visitBindingPattern(this);
2273         }
2274 
2275         @DefinedBy(Api.COMPILER_TREE)
2276         public Kind getKind() {
2277             return Kind.BINDING_PATTERN;
2278         }
2279 
2280         @Override
2281         @DefinedBy(Api.COMPILER_TREE)
2282         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
2283             return v.visitBindingPattern(this, d);
2284         }
2285 
2286         @Override
2287         public Tag getTag() {
2288             return BINDINGPATTERN;
2289         }
2290     }
2291 
2292     public static class JCDefaultCaseLabel extends JCCaseLabel
2293             implements DefaultCaseLabelTree {
2294 
2295         protected JCDefaultCaseLabel() {
2296         }
2297 
2298         @Override
2299         public void accept(Visitor v) {
2300             v.visitDefaultCaseLabel(this);
2301         }
2302 
2303         @DefinedBy(Api.COMPILER_TREE)
2304         public Kind getKind() {
2305             return Kind.DEFAULT_CASE_LABEL;
2306         }
2307 
2308         @Override
2309         @DefinedBy(Api.COMPILER_TREE)
2310         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
2311             return v.visitDefaultCaseLabel(this, d);
2312         }
2313 
2314         @Override
2315         public Tag getTag() {
2316             return DEFAULTCASELABEL;
2317         }
2318 
2319         @Override
2320         public boolean isExpression() {
2321             return false;
2322         }
2323 
2324         @Override
2325         public boolean isPattern() {
2326             return false;
2327         }
2328     }
2329 
2330     public static class JCParenthesizedPattern extends JCPattern
2331             implements ParenthesizedPatternTree {
2332         public JCPattern pattern;
2333 
2334         public JCParenthesizedPattern(JCPattern pattern) {
2335             this.pattern = pattern;
2336         }
2337 
2338         @Override @DefinedBy(Api.COMPILER_TREE)
2339         public PatternTree getPattern() {
2340             return pattern;
2341         }
2342 
2343         @Override
2344         public void accept(Visitor v) {
2345             v.visitParenthesizedPattern(this);
2346         }
2347 
2348         @DefinedBy(Api.COMPILER_TREE)
2349         public Kind getKind() {
2350             return Kind.PARENTHESIZED_PATTERN;
2351         }
2352 
2353         @Override
2354         @DefinedBy(Api.COMPILER_TREE)
2355         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
2356             return v.visitParenthesizedPattern(this, d);
2357         }
2358 
2359         @Override
2360         public Tag getTag() {
2361             return PARENTHESIZEDPATTERN;
2362         }
2363     }
2364 
2365     public static class JCGuardPattern extends JCPattern
2366             implements GuardedPatternTree {
2367         public JCPattern patt;
2368         public JCExpression expr;
2369 
2370         public JCGuardPattern(JCPattern patt, JCExpression expr) {
2371             this.patt = patt;
2372             this.expr = expr;
2373         }
2374 
2375         @Override @DefinedBy(Api.COMPILER_TREE)
2376         public PatternTree getPattern() {
2377             return patt;
2378         }
2379 
2380         @Override @DefinedBy(Api.COMPILER_TREE)
2381         public ExpressionTree getExpression() {
2382             return expr;
2383         }
2384 
2385         @Override
2386         public void accept(Visitor v) {
2387             v.visitGuardPattern(this);
2388         }
2389 
2390         @DefinedBy(Api.COMPILER_TREE)
2391         public Kind getKind() {
2392             return Kind.GUARDED_PATTERN;
2393         }
2394 
2395         @Override
2396         @DefinedBy(Api.COMPILER_TREE)
2397         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
2398             return v.visitGuardedPattern(this, d);
2399         }
2400 
2401         @Override
2402         public Tag getTag() {
2403             return Tag.GUARDPATTERN;
2404         }
2405     }
2406 
2407     /**
2408      * An array selection
2409      */
2410     public static class JCArrayAccess extends JCExpression implements ArrayAccessTree {
2411         public JCExpression indexed;
2412         public JCExpression index;
2413         protected JCArrayAccess(JCExpression indexed, JCExpression index) {
2414             this.indexed = indexed;
2415             this.index = index;
2416         }
2417         @Override
2418         public void accept(Visitor v) { v.visitIndexed(this); }
2419 
2420         @DefinedBy(Api.COMPILER_TREE)
2421         public Kind getKind() { return Kind.ARRAY_ACCESS; }
2422         @DefinedBy(Api.COMPILER_TREE)
2423         public JCExpression getExpression() { return indexed; }
2424         @DefinedBy(Api.COMPILER_TREE)
2425         public JCExpression getIndex() { return index; }
2426         @Override @DefinedBy(Api.COMPILER_TREE)
2427         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2428             return v.visitArrayAccess(this, d);
2429         }
2430         @Override
2431         public Tag getTag() {
2432             return INDEXED;
2433         }
2434     }
2435 
2436     /**
2437      * Selects through packages and classes
2438      */
2439     public static class JCFieldAccess extends JCExpression implements MemberSelectTree {
2440         /** selected Tree hierarchy */
2441         public JCExpression selected;
2442         /** name of field to select thru */
2443         public Name name;
2444         /** symbol of the selected class */
2445         public Symbol sym;
2446         protected JCFieldAccess(JCExpression selected, Name name, Symbol sym) {
2447             this.selected = selected;
2448             this.name = name;
2449             this.sym = sym;
2450         }
2451         @Override
2452         public void accept(Visitor v) { v.visitSelect(this); }
2453 
2454         @DefinedBy(Api.COMPILER_TREE)
2455         public Kind getKind() { return Kind.MEMBER_SELECT; }
2456         @DefinedBy(Api.COMPILER_TREE)
2457         public JCExpression getExpression() { return selected; }
2458         @Override @DefinedBy(Api.COMPILER_TREE)
2459         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2460             return v.visitMemberSelect(this, d);
2461         }
2462         @DefinedBy(Api.COMPILER_TREE)
2463         public Name getIdentifier() { return name; }
2464         @Override
2465         public Tag getTag() {
2466             return SELECT;
2467         }
2468     }
2469 
2470     /**
2471      * Selects a member expression.
2472      */
2473     public static class JCMemberReference extends JCFunctionalExpression implements MemberReferenceTree {
2474 
2475         public ReferenceMode mode;
2476         public ReferenceKind kind;
2477         public Name name;
2478         public JCExpression expr;
2479         public List<JCExpression> typeargs;
2480         public Symbol sym;
2481         public Type varargsElement;
2482         public PolyKind refPolyKind;
2483         public boolean ownerAccessible;
2484         private OverloadKind overloadKind;
2485         public Type referentType;
2486 
2487         public enum OverloadKind {
2488             OVERLOADED,
2489             UNOVERLOADED,
2490             ERROR
2491         }
2492 
2493         /**
2494          * Javac-dependent classification for member references, based
2495          * on relevant properties w.r.t. code-generation
2496          */
2497         public enum ReferenceKind {
2498             /** super # instMethod */
2499             SUPER(ReferenceMode.INVOKE, false),
2500             /** Type # instMethod */
2501             UNBOUND(ReferenceMode.INVOKE, true),
2502             /** Type # staticMethod */
2503             STATIC(ReferenceMode.INVOKE, false),
2504             /** Expr # instMethod */
2505             BOUND(ReferenceMode.INVOKE, false),
2506             /** Inner # new */
2507             IMPLICIT_INNER(ReferenceMode.NEW, false),
2508             /** Toplevel # new */
2509             TOPLEVEL(ReferenceMode.NEW, false),
2510             /** ArrayType # new */
2511             ARRAY_CTOR(ReferenceMode.NEW, false);
2512 
2513             final ReferenceMode mode;
2514             final boolean unbound;
2515 
2516             private ReferenceKind(ReferenceMode mode, boolean unbound) {
2517                 this.mode = mode;
2518                 this.unbound = unbound;
2519             }
2520 
2521             public boolean isUnbound() {
2522                 return unbound;
2523             }
2524         }
2525 
2526         public JCMemberReference(ReferenceMode mode, Name name, JCExpression expr, List<JCExpression> typeargs) {
2527             this.mode = mode;
2528             this.name = name;
2529             this.expr = expr;
2530             this.typeargs = typeargs;
2531         }
2532         @Override
2533         public void accept(Visitor v) { v.visitReference(this); }
2534 
2535         @DefinedBy(Api.COMPILER_TREE)
2536         public Kind getKind() { return Kind.MEMBER_REFERENCE; }
2537         @Override @DefinedBy(Api.COMPILER_TREE)
2538         public ReferenceMode getMode() { return mode; }
2539         @Override @DefinedBy(Api.COMPILER_TREE)
2540         public JCExpression getQualifierExpression() { return expr; }
2541         @Override @DefinedBy(Api.COMPILER_TREE)
2542         public Name getName() { return name; }
2543         @Override @DefinedBy(Api.COMPILER_TREE)
2544         public List<JCExpression> getTypeArguments() { return typeargs; }
2545 
2546         @Override @DefinedBy(Api.COMPILER_TREE)
2547         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2548             return v.visitMemberReference(this, d);
2549         }
2550         @Override
2551         public Tag getTag() {
2552             return REFERENCE;
2553         }
2554         public boolean hasKind(ReferenceKind kind) {
2555             return this.kind == kind;
2556         }
2557 
2558         /**
2559          * @return the overloadKind
2560          */
2561         public OverloadKind getOverloadKind() {
2562             return overloadKind;
2563         }
2564 
2565         /**
2566          * @param overloadKind the overloadKind to set
2567          */
2568         public void setOverloadKind(OverloadKind overloadKind) {
2569             this.overloadKind = overloadKind;
2570         }
2571     }
2572 
2573     /**
2574      * An identifier
2575      */
2576     public static class JCIdent extends JCExpression implements IdentifierTree {
2577         /** the name */
2578         public Name name;
2579         /** the symbol */
2580         public Symbol sym;
2581         protected JCIdent(Name name, Symbol sym) {
2582             this.name = name;
2583             this.sym = sym;
2584         }
2585         @Override
2586         public void accept(Visitor v) { v.visitIdent(this); }
2587 
2588         @DefinedBy(Api.COMPILER_TREE)
2589         public Kind getKind() { return Kind.IDENTIFIER; }
2590         @DefinedBy(Api.COMPILER_TREE)
2591         public Name getName() { return name; }
2592         @Override @DefinedBy(Api.COMPILER_TREE)
2593         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2594             return v.visitIdentifier(this, d);
2595         }
2596         @Override
2597         public Tag getTag() {
2598             return IDENT;
2599         }
2600     }
2601 
2602     /**
2603      * A constant value given literally.
2604      */
2605     public static class JCLiteral extends JCExpression implements LiteralTree {
2606         public TypeTag typetag;
2607         /** value representation */
2608         public Object value;
2609         protected JCLiteral(TypeTag typetag, Object value) {
2610             this.typetag = typetag;
2611             this.value = value;
2612         }
2613         @Override
2614         public void accept(Visitor v) { v.visitLiteral(this); }
2615 
2616         @DefinedBy(Api.COMPILER_TREE)
2617         public Kind getKind() {
2618             return typetag.getKindLiteral();
2619         }
2620 
2621         @DefinedBy(Api.COMPILER_TREE)
2622         public Object getValue() {
2623             switch (typetag) {
2624                 case BOOLEAN:
2625                     int bi = (Integer) value;
2626                     return (bi != 0);
2627                 case CHAR:
2628                     int ci = (Integer) value;
2629                     char c = (char) ci;
2630                     if (c != ci)
2631                         throw new AssertionError("bad value for char literal");
2632                     return c;
2633                 default:
2634                     return value;
2635             }
2636         }
2637         @Override @DefinedBy(Api.COMPILER_TREE)
2638         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2639             return v.visitLiteral(this, d);
2640         }
2641         @Override
2642         public JCLiteral setType(Type type) {
2643             super.setType(type);
2644             return this;
2645         }
2646         @Override
2647         public Tag getTag() {
2648             return LITERAL;
2649         }
2650     }
2651 
2652     /**
2653      * Identifies a basic type.
2654      * @see TypeTag
2655      */
2656     public static class JCPrimitiveTypeTree extends JCExpression implements PrimitiveTypeTree {
2657         /** the basic type id */
2658         public TypeTag typetag;
2659         protected JCPrimitiveTypeTree(TypeTag typetag) {
2660             this.typetag = typetag;
2661         }
2662         @Override
2663         public void accept(Visitor v) { v.visitTypeIdent(this); }
2664 
2665         @DefinedBy(Api.COMPILER_TREE)
2666         public Kind getKind() { return Kind.PRIMITIVE_TYPE; }
2667         @DefinedBy(Api.COMPILER_TREE)
2668         public TypeKind getPrimitiveTypeKind() {
2669             return typetag.getPrimitiveTypeKind();
2670         }
2671 
2672         @Override @DefinedBy(Api.COMPILER_TREE)
2673         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2674             return v.visitPrimitiveType(this, d);
2675         }
2676         @Override
2677         public Tag getTag() {
2678             return TYPEIDENT;
2679         }
2680     }
2681 
2682     /**
2683      * An array type, A[]
2684      */
2685     public static class JCArrayTypeTree extends JCExpression implements ArrayTypeTree {
2686         public JCExpression elemtype;
2687         protected JCArrayTypeTree(JCExpression elemtype) {
2688             this.elemtype = elemtype;
2689         }
2690         @Override
2691         public void accept(Visitor v) { v.visitTypeArray(this); }
2692 
2693         @DefinedBy(Api.COMPILER_TREE)
2694         public Kind getKind() { return Kind.ARRAY_TYPE; }
2695         @DefinedBy(Api.COMPILER_TREE)
2696         public JCTree getType() { return elemtype; }
2697         @Override @DefinedBy(Api.COMPILER_TREE)
2698         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2699             return v.visitArrayType(this, d);
2700         }
2701         @Override
2702         public Tag getTag() {
2703             return TYPEARRAY;
2704         }
2705     }
2706 
2707     /**
2708      * A parameterized type, {@literal T<...>}
2709      */
2710     public static class JCTypeApply extends JCExpression implements ParameterizedTypeTree {
2711         public JCExpression clazz;
2712         public List<JCExpression> arguments;
2713         protected JCTypeApply(JCExpression clazz, List<JCExpression> arguments) {
2714             this.clazz = clazz;
2715             this.arguments = arguments;
2716         }
2717         @Override
2718         public void accept(Visitor v) { v.visitTypeApply(this); }
2719 
2720         @DefinedBy(Api.COMPILER_TREE)
2721         public Kind getKind() { return Kind.PARAMETERIZED_TYPE; }
2722         @DefinedBy(Api.COMPILER_TREE)
2723         public JCTree getType() { return clazz; }
2724         @DefinedBy(Api.COMPILER_TREE)
2725         public List<JCExpression> getTypeArguments() {
2726             return arguments;
2727         }
2728         @Override @DefinedBy(Api.COMPILER_TREE)
2729         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2730             return v.visitParameterizedType(this, d);
2731         }
2732         @Override
2733         public Tag getTag() {
2734             return TYPEAPPLY;
2735         }
2736     }
2737 
2738     /**
2739      * A union type, T1 | T2 | ... Tn (used in multicatch statements)
2740      */
2741     public static class JCTypeUnion extends JCExpression implements UnionTypeTree {
2742 
2743         public List<JCExpression> alternatives;
2744 
2745         protected JCTypeUnion(List<JCExpression> components) {
2746             this.alternatives = components;
2747         }
2748         @Override
2749         public void accept(Visitor v) { v.visitTypeUnion(this); }
2750 
2751         @DefinedBy(Api.COMPILER_TREE)
2752         public Kind getKind() { return Kind.UNION_TYPE; }
2753 
2754         @DefinedBy(Api.COMPILER_TREE)
2755         public List<JCExpression> getTypeAlternatives() {
2756             return alternatives;
2757         }
2758         @Override @DefinedBy(Api.COMPILER_TREE)
2759         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2760             return v.visitUnionType(this, d);
2761         }
2762         @Override
2763         public Tag getTag() {
2764             return TYPEUNION;
2765         }
2766     }
2767 
2768     /**
2769      * An intersection type, {@code T1 & T2 & ... Tn} (used in cast expressions)
2770      */
2771     public static class JCTypeIntersection extends JCExpression implements IntersectionTypeTree {
2772 
2773         public List<JCExpression> bounds;
2774 
2775         protected JCTypeIntersection(List<JCExpression> bounds) {
2776             this.bounds = bounds;
2777         }
2778         @Override
2779         public void accept(Visitor v) { v.visitTypeIntersection(this); }
2780 
2781         @DefinedBy(Api.COMPILER_TREE)
2782         public Kind getKind() { return Kind.INTERSECTION_TYPE; }
2783 
2784         @DefinedBy(Api.COMPILER_TREE)
2785         public List<JCExpression> getBounds() {
2786             return bounds;
2787         }
2788         @Override @DefinedBy(Api.COMPILER_TREE)
2789         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2790             return v.visitIntersectionType(this, d);
2791         }
2792         @Override
2793         public Tag getTag() {
2794             return TYPEINTERSECTION;
2795         }
2796     }
2797 
2798     /**
2799      * A formal class parameter.
2800      */
2801     public static class JCTypeParameter extends JCTree implements TypeParameterTree {
2802         /** name */
2803         public Name name;
2804         /** bounds */
2805         public List<JCExpression> bounds;
2806         /** type annotations on type parameter */
2807         public List<JCAnnotation> annotations;
2808         protected JCTypeParameter(Name name, List<JCExpression> bounds, List<JCAnnotation> annotations) {
2809             this.name = name;
2810             this.bounds = bounds;
2811             this.annotations = annotations;
2812         }
2813         @Override
2814         public void accept(Visitor v) { v.visitTypeParameter(this); }
2815 
2816         @DefinedBy(Api.COMPILER_TREE)
2817         public Kind getKind() { return Kind.TYPE_PARAMETER; }
2818         @DefinedBy(Api.COMPILER_TREE)
2819         public Name getName() { return name; }
2820         @DefinedBy(Api.COMPILER_TREE)
2821         public List<JCExpression> getBounds() {
2822             return bounds;
2823         }
2824         @DefinedBy(Api.COMPILER_TREE)
2825         public List<JCAnnotation> getAnnotations() {
2826             return annotations;
2827         }
2828         @Override @DefinedBy(Api.COMPILER_TREE)
2829         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2830             return v.visitTypeParameter(this, d);
2831         }
2832         @Override
2833         public Tag getTag() {
2834             return TYPEPARAMETER;
2835         }
2836     }
2837 
2838     public static class JCWildcard extends JCExpression implements WildcardTree {
2839         public TypeBoundKind kind;
2840         public JCTree inner;
2841         protected JCWildcard(TypeBoundKind kind, JCTree inner) {
2842             this.kind = Assert.checkNonNull(kind);
2843             this.inner = inner;
2844         }
2845         @Override
2846         public void accept(Visitor v) { v.visitWildcard(this); }
2847 
2848         @DefinedBy(Api.COMPILER_TREE)
2849         public Kind getKind() {
2850             switch (kind.kind) {
2851             case UNBOUND:
2852                 return Kind.UNBOUNDED_WILDCARD;
2853             case EXTENDS:
2854                 return Kind.EXTENDS_WILDCARD;
2855             case SUPER:
2856                 return Kind.SUPER_WILDCARD;
2857             default:
2858                 throw new AssertionError("Unknown wildcard bound " + kind);
2859             }
2860         }
2861         @DefinedBy(Api.COMPILER_TREE)
2862         public JCTree getBound() { return inner; }
2863         @Override @DefinedBy(Api.COMPILER_TREE)
2864         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2865             return v.visitWildcard(this, d);
2866         }
2867         @Override
2868         public Tag getTag() {
2869             return Tag.WILDCARD;
2870         }
2871     }
2872 
2873     public static class TypeBoundKind extends JCTree {
2874         public BoundKind kind;
2875         protected TypeBoundKind(BoundKind kind) {
2876             this.kind = kind;
2877         }
2878         @Override
2879         public void accept(Visitor v) { v.visitTypeBoundKind(this); }
2880 
2881         @DefinedBy(Api.COMPILER_TREE)
2882         public Kind getKind() {
2883             throw new AssertionError("TypeBoundKind is not part of a public API");
2884         }
2885         @Override @DefinedBy(Api.COMPILER_TREE)
2886         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2887             throw new AssertionError("TypeBoundKind is not part of a public API");
2888         }
2889         @Override
2890         public Tag getTag() {
2891             return TYPEBOUNDKIND;
2892         }
2893     }
2894 
2895     public static class JCAnnotation extends JCExpression implements AnnotationTree {
2896         // Either Tag.ANNOTATION or Tag.TYPE_ANNOTATION
2897         private Tag tag;
2898 
2899         public JCTree annotationType;
2900         public List<JCExpression> args;
2901         public Attribute.Compound attribute;
2902 
2903         protected JCAnnotation(Tag tag, JCTree annotationType, List<JCExpression> args) {
2904             this.tag = tag;
2905             this.annotationType = annotationType;
2906             this.args = args;
2907         }
2908 
2909         @Override
2910         public void accept(Visitor v) { v.visitAnnotation(this); }
2911 
2912         @DefinedBy(Api.COMPILER_TREE)
2913         public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
2914 
2915         @DefinedBy(Api.COMPILER_TREE)
2916         public JCTree getAnnotationType() { return annotationType; }
2917         @DefinedBy(Api.COMPILER_TREE)
2918         public List<JCExpression> getArguments() {
2919             return args;
2920         }
2921         @Override @DefinedBy(Api.COMPILER_TREE)
2922         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2923             return v.visitAnnotation(this, d);
2924         }
2925         @Override
2926         public Tag getTag() {
2927             return tag;
2928         }
2929     }
2930 
2931     public static class JCModifiers extends JCTree implements com.sun.source.tree.ModifiersTree {
2932         public long flags;
2933         public List<JCAnnotation> annotations;
2934         protected JCModifiers(long flags, List<JCAnnotation> annotations) {
2935             this.flags = flags;
2936             this.annotations = annotations;
2937         }
2938         @Override
2939         public void accept(Visitor v) { v.visitModifiers(this); }
2940 
2941         @DefinedBy(Api.COMPILER_TREE)
2942         public Kind getKind() { return Kind.MODIFIERS; }
2943         @DefinedBy(Api.COMPILER_TREE)
2944         public Set<Modifier> getFlags() {
2945             return Flags.asModifierSet(flags);
2946         }
2947         @DefinedBy(Api.COMPILER_TREE)
2948         public List<JCAnnotation> getAnnotations() {
2949             return annotations;
2950         }
2951         @Override @DefinedBy(Api.COMPILER_TREE)
2952         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2953             return v.visitModifiers(this, d);
2954         }
2955         @Override
2956         public Tag getTag() {
2957             return MODIFIERS;
2958         }
2959     }
2960 
2961     public static class JCAnnotatedType extends JCExpression implements com.sun.source.tree.AnnotatedTypeTree {
2962         // type annotations
2963         public List<JCAnnotation> annotations;
2964         public JCExpression underlyingType;
2965 
2966         protected JCAnnotatedType(List<JCAnnotation> annotations, JCExpression underlyingType) {
2967             Assert.check(annotations != null && annotations.nonEmpty());
2968             this.annotations = annotations;
2969             this.underlyingType = underlyingType;
2970         }
2971         @Override
2972         public void accept(Visitor v) { v.visitAnnotatedType(this); }
2973 
2974         @DefinedBy(Api.COMPILER_TREE)
2975         public Kind getKind() { return Kind.ANNOTATED_TYPE; }
2976         @DefinedBy(Api.COMPILER_TREE)
2977         public List<JCAnnotation> getAnnotations() {
2978             return annotations;
2979         }
2980         @DefinedBy(Api.COMPILER_TREE)
2981         public JCExpression getUnderlyingType() {
2982             return underlyingType;
2983         }
2984         @Override @DefinedBy(Api.COMPILER_TREE)
2985         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2986             return v.visitAnnotatedType(this, d);
2987         }
2988         @Override
2989         public Tag getTag() {
2990             return ANNOTATED_TYPE;
2991         }
2992     }
2993 
2994     public abstract static class JCDirective extends JCTree
2995         implements DirectiveTree {
2996     }
2997 
2998     public static class JCModuleDecl extends JCTree implements ModuleTree {
2999         public JCModifiers mods;
3000         public ModuleType type;
3001         private final ModuleKind kind;
3002         public JCExpression qualId;
3003         public List<JCDirective> directives;
3004         public ModuleSymbol sym;
3005 
3006         protected JCModuleDecl(JCModifiers mods, ModuleKind kind,
3007                 JCExpression qualId, List<JCDirective> directives) {
3008             this.mods = mods;
3009             this.kind = kind;
3010             this.qualId = qualId;
3011             this.directives = directives;
3012         }
3013 
3014         @Override
3015         public void accept(Visitor v) { v.visitModuleDef(this); }
3016 
3017         @Override @DefinedBy(Api.COMPILER_TREE)
3018         public Kind getKind() {
3019             return Kind.MODULE;
3020         }
3021 
3022         @Override @DefinedBy(Api.COMPILER_TREE)
3023         public List<? extends AnnotationTree> getAnnotations() {
3024             return mods.annotations;
3025         }
3026 
3027         @Override @DefinedBy(Api.COMPILER_TREE)
3028         public ModuleKind getModuleType() {
3029             return kind;
3030         }
3031 
3032         @Override @DefinedBy(Api.COMPILER_TREE)
3033         public JCExpression getName() {
3034             return qualId;
3035         }
3036 
3037         @Override @DefinedBy(Api.COMPILER_TREE)
3038         public List<JCDirective> getDirectives() {
3039             return directives;
3040         }
3041 
3042         @Override @DefinedBy(Api.COMPILER_TREE)
3043         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
3044             return v.visitModule(this, d);
3045         }
3046 
3047         @Override
3048         public Tag getTag() {
3049             return MODULEDEF;
3050         }
3051     }
3052 
3053     public static class JCExports extends JCDirective
3054             implements ExportsTree {
3055         public JCExpression qualid;
3056         public List<JCExpression> moduleNames;
3057         public ExportsDirective directive;
3058 
3059         protected JCExports(JCExpression qualId, List<JCExpression> moduleNames) {
3060             this.qualid = qualId;
3061             this.moduleNames = moduleNames;
3062         }
3063 
3064         @Override
3065         public void accept(Visitor v) { v.visitExports(this); }
3066 
3067         @Override @DefinedBy(Api.COMPILER_TREE)
3068         public Kind getKind() {
3069             return Kind.EXPORTS;
3070         }
3071 
3072         @Override @DefinedBy(Api.COMPILER_TREE)
3073         public JCExpression getPackageName() {
3074             return qualid;
3075         }
3076 
3077         @Override @DefinedBy(Api.COMPILER_TREE)
3078         public List<JCExpression> getModuleNames() {
3079             return moduleNames;
3080         }
3081 
3082         @Override @DefinedBy(Api.COMPILER_TREE)
3083         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
3084             return v.visitExports(this, d);
3085         }
3086 
3087         @Override
3088         public Tag getTag() {
3089             return Tag.EXPORTS;
3090         }
3091     }
3092 
3093     public static class JCOpens extends JCDirective
3094             implements OpensTree {
3095         public JCExpression qualid;
3096         public List<JCExpression> moduleNames;
3097         public OpensDirective directive;
3098 
3099         protected JCOpens(JCExpression qualId, List<JCExpression> moduleNames) {
3100             this.qualid = qualId;
3101             this.moduleNames = moduleNames;
3102         }
3103 
3104         @Override
3105         public void accept(Visitor v) { v.visitOpens(this); }
3106 
3107         @Override @DefinedBy(Api.COMPILER_TREE)
3108         public Kind getKind() {
3109             return Kind.OPENS;
3110         }
3111 
3112         @Override @DefinedBy(Api.COMPILER_TREE)
3113         public JCExpression getPackageName() {
3114             return qualid;
3115         }
3116 
3117         @Override @DefinedBy(Api.COMPILER_TREE)
3118         public List<JCExpression> getModuleNames() {
3119             return moduleNames;
3120         }
3121 
3122         @Override @DefinedBy(Api.COMPILER_TREE)
3123         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
3124             return v.visitOpens(this, d);
3125         }
3126 
3127         @Override
3128         public Tag getTag() {
3129             return Tag.OPENS;
3130         }
3131     }
3132 
3133     public static class JCProvides extends JCDirective
3134             implements ProvidesTree {
3135         public JCExpression serviceName;
3136         public List<JCExpression> implNames;
3137 
3138         protected JCProvides(JCExpression serviceName, List<JCExpression> implNames) {
3139             this.serviceName = serviceName;
3140             this.implNames = implNames;
3141         }
3142 
3143         @Override
3144         public void accept(Visitor v) { v.visitProvides(this); }
3145 
3146         @Override @DefinedBy(Api.COMPILER_TREE)
3147         public Kind getKind() {
3148             return Kind.PROVIDES;
3149         }
3150 
3151         @Override @DefinedBy(Api.COMPILER_TREE)
3152         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
3153             return v.visitProvides(this, d);
3154         }
3155 
3156         @Override @DefinedBy(Api.COMPILER_TREE)
3157         public JCExpression getServiceName() {
3158             return serviceName;
3159         }
3160 
3161         @Override @DefinedBy(Api.COMPILER_TREE)
3162         public List<JCExpression> getImplementationNames() {
3163             return implNames;
3164         }
3165 
3166         @Override
3167         public Tag getTag() {
3168             return PROVIDES;
3169         }
3170     }
3171 
3172     public static class JCRequires extends JCDirective
3173             implements RequiresTree {
3174         public boolean isTransitive;
3175         public boolean isStaticPhase;
3176         public JCExpression moduleName;
3177         public RequiresDirective directive;
3178 
3179         protected JCRequires(boolean isTransitive, boolean isStaticPhase, JCExpression moduleName) {
3180             this.isTransitive = isTransitive;
3181             this.isStaticPhase = isStaticPhase;
3182             this.moduleName = moduleName;
3183         }
3184 
3185         @Override
3186         public void accept(Visitor v) { v.visitRequires(this); }
3187 
3188         @Override @DefinedBy(Api.COMPILER_TREE)
3189         public Kind getKind() {
3190             return Kind.REQUIRES;
3191         }
3192 
3193         @Override @DefinedBy(Api.COMPILER_TREE)
3194         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
3195             return v.visitRequires(this, d);
3196         }
3197 
3198         @Override @DefinedBy(Api.COMPILER_TREE)
3199         public boolean isTransitive() {
3200             return isTransitive;
3201         }
3202 
3203         @Override @DefinedBy(Api.COMPILER_TREE)
3204         public boolean isStatic() {
3205             return isStaticPhase;
3206         }
3207 
3208         @Override @DefinedBy(Api.COMPILER_TREE)
3209         public JCExpression getModuleName() {
3210             return moduleName;
3211         }
3212 
3213         @Override
3214         public Tag getTag() {
3215             return REQUIRES;
3216         }
3217     }
3218 
3219     public static class JCUses extends JCDirective
3220             implements UsesTree {
3221         public JCExpression qualid;
3222 
3223         protected JCUses(JCExpression qualId) {
3224             this.qualid = qualId;
3225         }
3226 
3227         @Override
3228         public void accept(Visitor v) { v.visitUses(this); }
3229 
3230         @Override @DefinedBy(Api.COMPILER_TREE)
3231         public Kind getKind() {
3232             return Kind.USES;
3233         }
3234 
3235         @Override @DefinedBy(Api.COMPILER_TREE)
3236         public JCExpression getServiceName() {
3237             return qualid;
3238         }
3239 
3240         @Override @DefinedBy(Api.COMPILER_TREE)
3241         public <R, D> R accept(TreeVisitor<R, D> v, D d) {
3242             return v.visitUses(this, d);
3243         }
3244 
3245         @Override
3246         public Tag getTag() {
3247             return USES;
3248         }
3249     }
3250 
3251     public static class JCErroneous extends JCExpression
3252             implements ErroneousTree {
3253         public List<? extends JCTree> errs;
3254         protected JCErroneous(List<? extends JCTree> errs) {
3255             this.errs = errs;
3256         }
3257         @Override
3258         public void accept(Visitor v) { v.visitErroneous(this); }
3259 
3260         @DefinedBy(Api.COMPILER_TREE)
3261         public Kind getKind() { return Kind.ERRONEOUS; }
3262 
3263         @DefinedBy(Api.COMPILER_TREE)
3264         public List<? extends JCTree> getErrorTrees() {
3265             return errs;
3266         }
3267 
3268         @Override @DefinedBy(Api.COMPILER_TREE)
3269         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
3270             return v.visitErroneous(this, d);
3271         }
3272         @Override
3273         public Tag getTag() {
3274             return ERRONEOUS;
3275         }
3276     }
3277 
3278     /** (let int x = 3; in x+2) */
3279     public static class LetExpr extends JCExpression {
3280         public List<JCStatement> defs;
3281         public JCExpression expr;
3282         /**true if a expr should be run through Gen.genCond:*/
3283         public boolean needsCond;
3284         protected LetExpr(List<JCStatement> defs, JCExpression expr) {
3285             this.defs = defs;
3286             this.expr = expr;
3287         }
3288         @Override
3289         public void accept(Visitor v) { v.visitLetExpr(this); }
3290 
3291         @DefinedBy(Api.COMPILER_TREE)
3292         public Kind getKind() {
3293             throw new AssertionError("LetExpr is not part of a public API");
3294         }
3295         @Override @DefinedBy(Api.COMPILER_TREE)
3296         public <R,D> R accept(TreeVisitor<R,D> v, D d) {
3297             throw new AssertionError("LetExpr is not part of a public API");
3298         }
3299         @Override
3300         public Tag getTag() {
3301             return LETEXPR;
3302         }
3303     }
3304 
3305     /** An interface for tree factories
3306      */
3307     public interface Factory {
3308         JCCompilationUnit TopLevel(List<JCTree> defs);
3309         JCPackageDecl PackageDecl(List<JCAnnotation> annotations,
3310                                   JCExpression pid);
3311         JCImport Import(JCTree qualid, boolean staticImport);
3312         JCClassDecl ClassDef(JCModifiers mods,
3313                           Name name,
3314                           List<JCTypeParameter> typarams,
3315                           JCExpression extending,
3316                           List<JCExpression> implementing,
3317                           List<JCTree> defs);
3318         JCMethodDecl MethodDef(JCModifiers mods,
3319                             Name name,
3320                             JCExpression restype,
3321                             List<JCTypeParameter> typarams,
3322                             JCVariableDecl recvparam,
3323                             List<JCVariableDecl> params,
3324                             List<JCExpression> thrown,
3325                             JCBlock body,
3326                             JCExpression defaultValue);
3327         JCVariableDecl VarDef(JCModifiers mods,
3328                       Name name,
3329                       JCExpression vartype,
3330                       JCExpression init);
3331         JCSkip Skip();
3332         JCBlock Block(long flags, List<JCStatement> stats);
3333         JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond);
3334         JCWhileLoop WhileLoop(JCExpression cond, JCStatement body);
3335         JCForLoop ForLoop(List<JCStatement> init,
3336                         JCExpression cond,
3337                         List<JCExpressionStatement> step,
3338                         JCStatement body);
3339         JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);
3340         JCLabeledStatement Labelled(Name label, JCStatement body);
3341         JCSwitch Switch(JCExpression selector, List<JCCase> cases);
3342         JCSwitchExpression SwitchExpression(JCExpression selector, List<JCCase> cases);
3343         JCCase Case(CaseTree.CaseKind caseKind, List<JCCaseLabel> labels,
3344                     List<JCStatement> stats, JCTree body);

3345         JCSynchronized Synchronized(JCExpression lock, JCBlock body);
3346         JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer);
3347         JCTry Try(List<JCTree> resources,
3348                   JCBlock body,
3349                   List<JCCatch> catchers,
3350                   JCBlock finalizer);
3351         JCCatch Catch(JCVariableDecl param, JCBlock body);
3352         JCConditional Conditional(JCExpression cond,
3353                                 JCExpression thenpart,
3354                                 JCExpression elsepart);
3355         JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);
3356         JCExpressionStatement Exec(JCExpression expr);
3357         JCBreak Break(Name label);
3358         JCYield Yield(JCExpression value);
3359         JCContinue Continue(Name label);
3360         JCReturn Return(JCExpression expr);
3361         JCThrow Throw(JCExpression expr);
3362         JCAssert Assert(JCExpression cond, JCExpression detail);
3363         JCMethodInvocation Apply(List<JCExpression> typeargs,
3364                     JCExpression fn,
3365                     List<JCExpression> args);
3366         JCNewClass NewClass(JCExpression encl,
3367                           List<JCExpression> typeargs,
3368                           JCExpression clazz,
3369                           List<JCExpression> args,
3370                           JCClassDecl def);
3371         JCNewArray NewArray(JCExpression elemtype,
3372                           List<JCExpression> dims,
3373                           List<JCExpression> elems);
3374         JCParens Parens(JCExpression expr);
3375         JCAssign Assign(JCExpression lhs, JCExpression rhs);
3376         JCAssignOp Assignop(Tag opcode, JCTree lhs, JCTree rhs);
3377         JCUnary Unary(Tag opcode, JCExpression arg);
3378         JCBinary Binary(Tag opcode, JCExpression lhs, JCExpression rhs);
3379         JCTypeCast TypeCast(JCTree expr, JCExpression type);
3380         JCInstanceOf TypeTest(JCExpression expr, JCTree clazz);
3381         JCBindingPattern BindingPattern(JCVariableDecl var);
3382         JCArrayAccess Indexed(JCExpression indexed, JCExpression index);
3383         JCFieldAccess Select(JCExpression selected, Name selector);
3384         JCIdent Ident(Name idname);
3385         JCLiteral Literal(TypeTag tag, Object value);
3386         JCPrimitiveTypeTree TypeIdent(TypeTag typetag);
3387         JCArrayTypeTree TypeArray(JCExpression elemtype);
3388         JCTypeApply TypeApply(JCExpression clazz, List<JCExpression> arguments);
3389         JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds);
3390         JCWildcard Wildcard(TypeBoundKind kind, JCTree type);
3391         TypeBoundKind TypeBoundKind(BoundKind kind);
3392         JCAnnotation Annotation(JCTree annotationType, List<JCExpression> args);
3393         JCModifiers Modifiers(long flags, List<JCAnnotation> annotations);
3394         JCErroneous Erroneous(List<? extends JCTree> errs);
3395         JCModuleDecl ModuleDef(JCModifiers mods, ModuleKind kind, JCExpression qualId, List<JCDirective> directives);
3396         JCExports Exports(JCExpression qualId, List<JCExpression> moduleNames);
3397         JCOpens Opens(JCExpression qualId, List<JCExpression> moduleNames);
3398         JCProvides Provides(JCExpression serviceName, List<JCExpression> implNames);
3399         JCRequires Requires(boolean isTransitive, boolean isStaticPhase, JCExpression qualId);
3400         JCUses Uses(JCExpression qualId);
3401         LetExpr LetExpr(List<JCStatement> defs, JCExpression expr);
3402     }
3403 
3404     /** A generic visitor class for trees.
3405      */
3406     public abstract static class Visitor {
3407         public void visitTopLevel(JCCompilationUnit that)    { visitTree(that); }
3408         public void visitPackageDef(JCPackageDecl that)      { visitTree(that); }
3409         public void visitImport(JCImport that)               { visitTree(that); }
3410         public void visitClassDef(JCClassDecl that)          { visitTree(that); }
3411         public void visitMethodDef(JCMethodDecl that)        { visitTree(that); }
3412         public void visitVarDef(JCVariableDecl that)         { visitTree(that); }
3413         public void visitSkip(JCSkip that)                   { visitTree(that); }
3414         public void visitBlock(JCBlock that)                 { visitTree(that); }
3415         public void visitDoLoop(JCDoWhileLoop that)          { visitTree(that); }
3416         public void visitWhileLoop(JCWhileLoop that)         { visitTree(that); }

3417         public void visitForLoop(JCForLoop that)             { visitTree(that); }
3418         public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }
3419         public void visitLabelled(JCLabeledStatement that)   { visitTree(that); }
3420         public void visitSwitch(JCSwitch that)               { visitTree(that); }
3421         public void visitCase(JCCase that)                   { visitTree(that); }

3422         public void visitSwitchExpression(JCSwitchExpression that)               { visitTree(that); }
3423         public void visitSynchronized(JCSynchronized that)   { visitTree(that); }
3424         public void visitTry(JCTry that)                     { visitTree(that); }
3425         public void visitCatch(JCCatch that)                 { visitTree(that); }
3426         public void visitConditional(JCConditional that)     { visitTree(that); }
3427         public void visitIf(JCIf that)                       { visitTree(that); }
3428         public void visitExec(JCExpressionStatement that)    { visitTree(that); }
3429         public void visitBreak(JCBreak that)                 { visitTree(that); }
3430         public void visitYield(JCYield that)                 { visitTree(that); }
3431         public void visitContinue(JCContinue that)           { visitTree(that); }
3432         public void visitReturn(JCReturn that)               { visitTree(that); }
3433         public void visitThrow(JCThrow that)                 { visitTree(that); }
3434         public void visitAssert(JCAssert that)               { visitTree(that); }
3435         public void visitApply(JCMethodInvocation that)      { visitTree(that); }
3436         public void visitNewClass(JCNewClass that)           { visitTree(that); }
3437         public void visitNewArray(JCNewArray that)           { visitTree(that); }
3438         public void visitLambda(JCLambda that)               { visitTree(that); }
3439         public void visitParens(JCParens that)               { visitTree(that); }
3440         public void visitAssign(JCAssign that)               { visitTree(that); }
3441         public void visitAssignop(JCAssignOp that)           { visitTree(that); }
3442         public void visitUnary(JCUnary that)                 { visitTree(that); }
3443         public void visitBinary(JCBinary that)               { visitTree(that); }
3444         public void visitTypeCast(JCTypeCast that)           { visitTree(that); }
3445         public void visitTypeTest(JCInstanceOf that)         { visitTree(that); }
3446         public void visitBindingPattern(JCBindingPattern that) { visitTree(that); }
3447         public void visitDefaultCaseLabel(JCDefaultCaseLabel that) { visitTree(that); }
3448         public void visitParenthesizedPattern(JCParenthesizedPattern that) { visitTree(that); }
3449         public void visitGuardPattern(JCGuardPattern that) { visitTree(that); }
3450         public void visitIndexed(JCArrayAccess that)         { visitTree(that); }
3451         public void visitSelect(JCFieldAccess that)          { visitTree(that); }
3452         public void visitReference(JCMemberReference that)   { visitTree(that); }
3453         public void visitIdent(JCIdent that)                 { visitTree(that); }
3454         public void visitLiteral(JCLiteral that)             { visitTree(that); }
3455         public void visitTypeIdent(JCPrimitiveTypeTree that) { visitTree(that); }
3456         public void visitTypeArray(JCArrayTypeTree that)     { visitTree(that); }
3457         public void visitTypeApply(JCTypeApply that)         { visitTree(that); }
3458         public void visitTypeUnion(JCTypeUnion that)         { visitTree(that); }
3459         public void visitTypeIntersection(JCTypeIntersection that)  { visitTree(that); }
3460         public void visitTypeParameter(JCTypeParameter that) { visitTree(that); }
3461         public void visitWildcard(JCWildcard that)           { visitTree(that); }
3462         public void visitTypeBoundKind(TypeBoundKind that)   { visitTree(that); }
3463         public void visitAnnotation(JCAnnotation that)       { visitTree(that); }
3464         public void visitModifiers(JCModifiers that)         { visitTree(that); }
3465         public void visitAnnotatedType(JCAnnotatedType that) { visitTree(that); }
3466         public void visitErroneous(JCErroneous that)         { visitTree(that); }
3467         public void visitModuleDef(JCModuleDecl that)        { visitTree(that); }
3468         public void visitExports(JCExports that)             { visitTree(that); }
3469         public void visitOpens(JCOpens that)                 { visitTree(that); }
3470         public void visitProvides(JCProvides that)           { visitTree(that); }
3471         public void visitRequires(JCRequires that)           { visitTree(that); }
3472         public void visitUses(JCUses that)                   { visitTree(that); }
3473         public void visitLetExpr(LetExpr that)               { visitTree(that); }
3474 
3475         public void visitTree(JCTree that)                   { Assert.error(); }
3476     }
3477 
3478 }
--- EOF ---