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