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