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