Tue, 25 Sep 2012 13:11:05 -0700
7196464: upgrade JavaCompiler.shouldStopPolicy to accomodate policies in face of error and no error
Reviewed-by: mcimadamore
1 /*
2 * Copyright (c) 1999, 2012, 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 */
26 package com.sun.tools.javac.tree;
28 import java.io.IOException;
29 import java.io.StringWriter;
30 import java.util.*;
32 import javax.lang.model.element.Modifier;
33 import javax.lang.model.type.TypeKind;
34 import javax.tools.JavaFileObject;
36 import com.sun.source.tree.*;
37 import com.sun.source.tree.LambdaExpressionTree.BodyKind;
38 import com.sun.source.tree.MemberReferenceTree.ReferenceMode;
39 import com.sun.tools.javac.code.*;
40 import com.sun.tools.javac.code.Scope.*;
41 import com.sun.tools.javac.code.Symbol.*;
42 import com.sun.tools.javac.util.*;
43 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
44 import com.sun.tools.javac.util.List;
45 import static com.sun.tools.javac.code.BoundKind.*;
46 import static com.sun.tools.javac.tree.JCTree.Tag.*;
48 /**
49 * Root class for abstract syntax tree nodes. It provides definitions
50 * for specific tree nodes as subclasses nested inside.
51 *
52 * <p>Each subclass is highly standardized. It generally contains
53 * only tree fields for the syntactic subcomponents of the node. Some
54 * classes that represent identifier uses or definitions also define a
55 * Symbol field that denotes the represented identifier. Classes for
56 * non-local jumps also carry the jump target as a field. The root
57 * class Tree itself defines fields for the tree's type and position.
58 * No other fields are kept in a tree node; instead parameters are
59 * passed to methods accessing the node.
60 *
61 * <p>Except for the methods defined by com.sun.source, the only
62 * method defined in subclasses is `visit' which applies a given
63 * visitor to the tree. The actual tree processing is done by visitor
64 * classes in other packages. The abstract class Visitor, as well as
65 * an Factory interface for trees, are defined as inner classes in
66 * Tree.
67 *
68 * <p>To avoid ambiguities with the Tree API in com.sun.source all sub
69 * classes should, by convention, start with JC (javac).
70 *
71 * <p><b>This is NOT part of any supported API.
72 * If you write code that depends on this, you do so at your own risk.
73 * This code and its internal interfaces are subject to change or
74 * deletion without notice.</b>
75 *
76 * @see TreeMaker
77 * @see TreeInfo
78 * @see TreeTranslator
79 * @see Pretty
80 */
81 public abstract class JCTree implements Tree, Cloneable, DiagnosticPosition {
83 /* Tree tag values, identifying kinds of trees */
84 public enum Tag{
85 /** For methods that return an invalid tag if a given condition is not met
86 */
87 NO_TAG,
89 /** Toplevel nodes, of type TopLevel, representing entire source files.
90 */
91 TOPLEVEL,
93 /** Import clauses, of type Import.
94 */
95 IMPORT,
97 /** Class definitions, of type ClassDef.
98 */
99 CLASSDEF,
101 /** Method definitions, of type MethodDef.
102 */
103 METHODDEF,
105 /** Variable definitions, of type VarDef.
106 */
107 VARDEF,
109 /** The no-op statement ";", of type Skip
110 */
111 SKIP,
113 /** Blocks, of type Block.
114 */
115 BLOCK,
117 /** Do-while loops, of type DoLoop.
118 */
119 DOLOOP,
121 /** While-loops, of type WhileLoop.
122 */
123 WHILELOOP,
125 /** For-loops, of type ForLoop.
126 */
127 FORLOOP,
129 /** Foreach-loops, of type ForeachLoop.
130 */
131 FOREACHLOOP,
133 /** Labelled statements, of type Labelled.
134 */
135 LABELLED,
137 /** Switch statements, of type Switch.
138 */
139 SWITCH,
141 /** Case parts in switch statements, of type Case.
142 */
143 CASE,
145 /** Synchronized statements, of type Synchonized.
146 */
147 SYNCHRONIZED,
149 /** Try statements, of type Try.
150 */
151 TRY,
153 /** Catch clauses in try statements, of type Catch.
154 */
155 CATCH,
157 /** Conditional expressions, of type Conditional.
158 */
159 CONDEXPR,
161 /** Conditional statements, of type If.
162 */
163 IF,
165 /** Expression statements, of type Exec.
166 */
167 EXEC,
169 /** Break statements, of type Break.
170 */
171 BREAK,
173 /** Continue statements, of type Continue.
174 */
175 CONTINUE,
177 /** Return statements, of type Return.
178 */
179 RETURN,
181 /** Throw statements, of type Throw.
182 */
183 THROW,
185 /** Assert statements, of type Assert.
186 */
187 ASSERT,
189 /** Method invocation expressions, of type Apply.
190 */
191 APPLY,
193 /** Class instance creation expressions, of type NewClass.
194 */
195 NEWCLASS,
197 /** Array creation expressions, of type NewArray.
198 */
199 NEWARRAY,
201 /** Lambda expression, of type Lambda.
202 */
203 LAMBDA,
205 /** Parenthesized subexpressions, of type Parens.
206 */
207 PARENS,
209 /** Assignment expressions, of type Assign.
210 */
211 ASSIGN,
213 /** Type cast expressions, of type TypeCast.
214 */
215 TYPECAST,
217 /** Type test expressions, of type TypeTest.
218 */
219 TYPETEST,
221 /** Indexed array expressions, of type Indexed.
222 */
223 INDEXED,
225 /** Selections, of type Select.
226 */
227 SELECT,
229 /** Member references, of type Reference.
230 */
231 REFERENCE,
233 /** Simple identifiers, of type Ident.
234 */
235 IDENT,
237 /** Literals, of type Literal.
238 */
239 LITERAL,
241 /** Basic type identifiers, of type TypeIdent.
242 */
243 TYPEIDENT,
245 /** Array types, of type TypeArray.
246 */
247 TYPEARRAY,
249 /** Parameterized types, of type TypeApply.
250 */
251 TYPEAPPLY,
253 /** Union types, of type TypeUnion
254 */
255 TYPEUNION,
257 /** Formal type parameters, of type TypeParameter.
258 */
259 TYPEPARAMETER,
261 /** Type argument.
262 */
263 WILDCARD,
265 /** Bound kind: extends, super, exact, or unbound
266 */
267 TYPEBOUNDKIND,
269 /** metadata: Annotation.
270 */
271 ANNOTATION,
273 /** metadata: Modifiers
274 */
275 MODIFIERS,
277 ANNOTATED_TYPE,
279 /** Error trees, of type Erroneous.
280 */
281 ERRONEOUS,
283 /** Unary operators, of type Unary.
284 */
285 POS, // +
286 NEG, // -
287 NOT, // !
288 COMPL, // ~
289 PREINC, // ++ _
290 PREDEC, // -- _
291 POSTINC, // _ ++
292 POSTDEC, // _ --
294 /** unary operator for null reference checks, only used internally.
295 */
296 NULLCHK,
298 /** Binary operators, of type Binary.
299 */
300 OR, // ||
301 AND, // &&
302 BITOR, // |
303 BITXOR, // ^
304 BITAND, // &
305 EQ, // ==
306 NE, // !=
307 LT, // <
308 GT, // >
309 LE, // <=
310 GE, // >=
311 SL, // <<
312 SR, // >>
313 USR, // >>>
314 PLUS, // +
315 MINUS, // -
316 MUL, // *
317 DIV, // /
318 MOD, // %
320 /** Assignment operators, of type Assignop.
321 */
322 BITOR_ASG(BITOR), // |=
323 BITXOR_ASG(BITXOR), // ^=
324 BITAND_ASG(BITAND), // &=
326 SL_ASG(SL), // <<=
327 SR_ASG(SR), // >>=
328 USR_ASG(USR), // >>>=
329 PLUS_ASG(PLUS), // +=
330 MINUS_ASG(MINUS), // -=
331 MUL_ASG(MUL), // *=
332 DIV_ASG(DIV), // /=
333 MOD_ASG(MOD), // %=
335 /** A synthetic let expression, of type LetExpr.
336 */
337 LETEXPR; // ala scheme
339 private Tag noAssignTag;
341 private static int numberOfOperators = MOD.ordinal() - POS.ordinal() + 1;
343 private Tag(Tag noAssignTag) {
344 this.noAssignTag = noAssignTag;
345 }
347 private Tag() { }
349 public static int getNumberOfOperators() {
350 return numberOfOperators;
351 }
353 public Tag noAssignOp() {
354 if (noAssignTag != null)
355 return noAssignTag;
356 throw new AssertionError("noAssignOp() method is not available for non assignment tags");
357 }
359 public boolean isPostUnaryOp() {
360 return (this == POSTINC || this == POSTDEC);
361 }
363 public boolean isIncOrDecUnaryOp() {
364 return (this == PREINC || this == PREDEC || this == POSTINC || this == POSTDEC);
365 }
367 public boolean isAssignop() {
368 return noAssignTag != null;
369 }
371 public int operatorIndex() {
372 return (this.ordinal() - POS.ordinal());
373 }
374 }
376 /* The (encoded) position in the source file. @see util.Position.
377 */
378 public int pos;
380 /* The type of this node.
381 */
382 public Type type;
384 /* The tag of this node -- one of the constants declared above.
385 */
386 public abstract Tag getTag();
388 /* Returns true if the tag of this node is equals to tag.
389 */
390 public boolean hasTag(Tag tag) {
391 return tag == getTag();
392 }
394 /** Convert a tree to a pretty-printed string. */
395 @Override
396 public String toString() {
397 StringWriter s = new StringWriter();
398 try {
399 new Pretty(s, false).printExpr(this);
400 }
401 catch (IOException e) {
402 // should never happen, because StringWriter is defined
403 // never to throw any IOExceptions
404 throw new AssertionError(e);
405 }
406 return s.toString();
407 }
409 /** Set position field and return this tree.
410 */
411 public JCTree setPos(int pos) {
412 this.pos = pos;
413 return this;
414 }
416 /** Set type field and return this tree.
417 */
418 public JCTree setType(Type type) {
419 this.type = type;
420 return this;
421 }
423 /** Visit this tree with a given visitor.
424 */
425 public abstract void accept(Visitor v);
427 public abstract <R,D> R accept(TreeVisitor<R,D> v, D d);
429 /** Return a shallow copy of this tree.
430 */
431 @Override
432 public Object clone() {
433 try {
434 return super.clone();
435 } catch(CloneNotSupportedException e) {
436 throw new RuntimeException(e);
437 }
438 }
440 /** Get a default position for this tree node.
441 */
442 public DiagnosticPosition pos() {
443 return this;
444 }
446 // for default DiagnosticPosition
447 public JCTree getTree() {
448 return this;
449 }
451 // for default DiagnosticPosition
452 public int getStartPosition() {
453 return TreeInfo.getStartPos(this);
454 }
456 // for default DiagnosticPosition
457 public int getPreferredPosition() {
458 return pos;
459 }
461 // for default DiagnosticPosition
462 public int getEndPosition(EndPosTable endPosTable) {
463 return TreeInfo.getEndPos(this, endPosTable);
464 }
466 /**
467 * Everything in one source file is kept in a TopLevel structure.
468 * @param pid The tree representing the package clause.
469 * @param sourcefile The source file name.
470 * @param defs All definitions in this file (ClassDef, Import, and Skip)
471 * @param packge The package it belongs to.
472 * @param namedImportScope A scope for all named imports.
473 * @param starImportScope A scope for all import-on-demands.
474 * @param lineMap Line starting positions, defined only
475 * if option -g is set.
476 * @param docComments A hashtable that stores all documentation comments
477 * indexed by the tree nodes they refer to.
478 * defined only if option -s is set.
479 * @param endPositions An object encapsulating ending positions of source
480 * ranges indexed by the tree nodes they belong to.
481 * Defined only if option -Xjcov is set.
482 */
483 public static class JCCompilationUnit extends JCTree implements CompilationUnitTree {
484 public List<JCAnnotation> packageAnnotations;
485 public JCExpression pid;
486 public List<JCTree> defs;
487 public JavaFileObject sourcefile;
488 public PackageSymbol packge;
489 public ImportScope namedImportScope;
490 public StarImportScope starImportScope;
491 public Position.LineMap lineMap = null;
492 public DocCommentTable docComments = null;
493 public EndPosTable endPositions = null;
494 protected JCCompilationUnit(List<JCAnnotation> packageAnnotations,
495 JCExpression pid,
496 List<JCTree> defs,
497 JavaFileObject sourcefile,
498 PackageSymbol packge,
499 ImportScope namedImportScope,
500 StarImportScope starImportScope) {
501 this.packageAnnotations = packageAnnotations;
502 this.pid = pid;
503 this.defs = defs;
504 this.sourcefile = sourcefile;
505 this.packge = packge;
506 this.namedImportScope = namedImportScope;
507 this.starImportScope = starImportScope;
508 }
509 @Override
510 public void accept(Visitor v) { v.visitTopLevel(this); }
512 public Kind getKind() { return Kind.COMPILATION_UNIT; }
513 public List<JCAnnotation> getPackageAnnotations() {
514 return packageAnnotations;
515 }
516 public List<JCImport> getImports() {
517 ListBuffer<JCImport> imports = new ListBuffer<JCImport>();
518 for (JCTree tree : defs) {
519 if (tree.hasTag(IMPORT))
520 imports.append((JCImport)tree);
521 else if (!tree.hasTag(SKIP))
522 break;
523 }
524 return imports.toList();
525 }
526 public JCExpression getPackageName() { return pid; }
527 public JavaFileObject getSourceFile() {
528 return sourcefile;
529 }
530 public Position.LineMap getLineMap() {
531 return lineMap;
532 }
533 public List<JCTree> getTypeDecls() {
534 List<JCTree> typeDefs;
535 for (typeDefs = defs; !typeDefs.isEmpty(); typeDefs = typeDefs.tail)
536 if (!typeDefs.head.hasTag(IMPORT))
537 break;
538 return typeDefs;
539 }
540 @Override
541 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
542 return v.visitCompilationUnit(this, d);
543 }
545 @Override
546 public Tag getTag() {
547 return TOPLEVEL;
548 }
549 }
551 /**
552 * An import clause.
553 * @param qualid The imported class(es).
554 */
555 public static class JCImport extends JCTree implements ImportTree {
556 public boolean staticImport;
557 public JCTree qualid;
558 protected JCImport(JCTree qualid, boolean importStatic) {
559 this.qualid = qualid;
560 this.staticImport = importStatic;
561 }
562 @Override
563 public void accept(Visitor v) { v.visitImport(this); }
565 public boolean isStatic() { return staticImport; }
566 public JCTree getQualifiedIdentifier() { return qualid; }
568 public Kind getKind() { return Kind.IMPORT; }
569 @Override
570 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
571 return v.visitImport(this, d);
572 }
574 @Override
575 public Tag getTag() {
576 return IMPORT;
577 }
578 }
580 public static abstract class JCStatement extends JCTree implements StatementTree {
581 @Override
582 public JCStatement setType(Type type) {
583 super.setType(type);
584 return this;
585 }
586 @Override
587 public JCStatement setPos(int pos) {
588 super.setPos(pos);
589 return this;
590 }
591 }
593 public static abstract class JCExpression extends JCTree implements ExpressionTree {
594 @Override
595 public JCExpression setType(Type type) {
596 super.setType(type);
597 return this;
598 }
599 @Override
600 public JCExpression setPos(int pos) {
601 super.setPos(pos);
602 return this;
603 }
604 }
606 /**
607 * A class definition.
608 * @param modifiers the modifiers
609 * @param name the name of the class
610 * @param typarams formal class parameters
611 * @param extending the classes this class extends
612 * @param implementing the interfaces implemented by this class
613 * @param defs all variables and methods defined in this class
614 * @param sym the symbol
615 */
616 public static class JCClassDecl extends JCStatement implements ClassTree {
617 public JCModifiers mods;
618 public Name name;
619 public List<JCTypeParameter> typarams;
620 public JCExpression extending;
621 public List<JCExpression> implementing;
622 public List<JCTree> defs;
623 public ClassSymbol sym;
624 protected JCClassDecl(JCModifiers mods,
625 Name name,
626 List<JCTypeParameter> typarams,
627 JCExpression extending,
628 List<JCExpression> implementing,
629 List<JCTree> defs,
630 ClassSymbol sym)
631 {
632 this.mods = mods;
633 this.name = name;
634 this.typarams = typarams;
635 this.extending = extending;
636 this.implementing = implementing;
637 this.defs = defs;
638 this.sym = sym;
639 }
640 @Override
641 public void accept(Visitor v) { v.visitClassDef(this); }
643 public Kind getKind() {
644 if ((mods.flags & Flags.ANNOTATION) != 0)
645 return Kind.ANNOTATION_TYPE;
646 else if ((mods.flags & Flags.INTERFACE) != 0)
647 return Kind.INTERFACE;
648 else if ((mods.flags & Flags.ENUM) != 0)
649 return Kind.ENUM;
650 else
651 return Kind.CLASS;
652 }
654 public JCModifiers getModifiers() { return mods; }
655 public Name getSimpleName() { return name; }
656 public List<JCTypeParameter> getTypeParameters() {
657 return typarams;
658 }
659 public JCTree getExtendsClause() { return extending; }
660 public List<JCExpression> getImplementsClause() {
661 return implementing;
662 }
663 public List<JCTree> getMembers() {
664 return defs;
665 }
666 @Override
667 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
668 return v.visitClass(this, d);
669 }
671 @Override
672 public Tag getTag() {
673 return CLASSDEF;
674 }
675 }
677 /**
678 * A method definition.
679 * @param modifiers method modifiers
680 * @param name method name
681 * @param restype type of method return value
682 * @param typarams type parameters
683 * @param params value parameters
684 * @param thrown exceptions thrown by this method
685 * @param stats statements in the method
686 * @param sym method symbol
687 */
688 public static class JCMethodDecl extends JCTree implements MethodTree {
689 public JCModifiers mods;
690 public Name name;
691 public JCExpression restype;
692 public List<JCTypeParameter> typarams;
693 public List<JCVariableDecl> params;
694 public List<JCExpression> thrown;
695 public JCBlock body;
696 public JCExpression defaultValue; // for annotation types
697 public MethodSymbol sym;
698 protected JCMethodDecl(JCModifiers mods,
699 Name name,
700 JCExpression restype,
701 List<JCTypeParameter> typarams,
702 List<JCVariableDecl> params,
703 List<JCExpression> thrown,
704 JCBlock body,
705 JCExpression defaultValue,
706 MethodSymbol sym)
707 {
708 this.mods = mods;
709 this.name = name;
710 this.restype = restype;
711 this.typarams = typarams;
712 this.params = params;
713 this.thrown = thrown;
714 this.body = body;
715 this.defaultValue = defaultValue;
716 this.sym = sym;
717 }
718 @Override
719 public void accept(Visitor v) { v.visitMethodDef(this); }
721 public Kind getKind() { return Kind.METHOD; }
722 public JCModifiers getModifiers() { return mods; }
723 public Name getName() { return name; }
724 public JCTree getReturnType() { return restype; }
725 public List<JCTypeParameter> getTypeParameters() {
726 return typarams;
727 }
728 public List<JCVariableDecl> getParameters() {
729 return params;
730 }
731 public List<JCExpression> getThrows() {
732 return thrown;
733 }
734 public JCBlock getBody() { return body; }
735 public JCTree getDefaultValue() { // for annotation types
736 return defaultValue;
737 }
738 @Override
739 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
740 return v.visitMethod(this, d);
741 }
743 @Override
744 public Tag getTag() {
745 return METHODDEF;
746 }
747 }
749 /**
750 * A variable definition.
751 * @param modifiers variable modifiers
752 * @param name variable name
753 * @param vartype type of the variable
754 * @param init variables initial value
755 * @param sym symbol
756 */
757 public static class JCVariableDecl extends JCStatement implements VariableTree {
758 public JCModifiers mods;
759 public Name name;
760 public JCExpression vartype;
761 public JCExpression init;
762 public VarSymbol sym;
763 protected JCVariableDecl(JCModifiers mods,
764 Name name,
765 JCExpression vartype,
766 JCExpression init,
767 VarSymbol sym) {
768 this.mods = mods;
769 this.name = name;
770 this.vartype = vartype;
771 this.init = init;
772 this.sym = sym;
773 }
774 @Override
775 public void accept(Visitor v) { v.visitVarDef(this); }
777 public Kind getKind() { return Kind.VARIABLE; }
778 public JCModifiers getModifiers() { return mods; }
779 public Name getName() { return name; }
780 public JCTree getType() { return vartype; }
781 public JCExpression getInitializer() {
782 return init;
783 }
784 @Override
785 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
786 return v.visitVariable(this, d);
787 }
789 @Override
790 public Tag getTag() {
791 return VARDEF;
792 }
793 }
795 /**
796 * A no-op statement ";".
797 */
798 public static class JCSkip extends JCStatement implements EmptyStatementTree {
799 protected JCSkip() {
800 }
801 @Override
802 public void accept(Visitor v) { v.visitSkip(this); }
804 public Kind getKind() { return Kind.EMPTY_STATEMENT; }
805 @Override
806 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
807 return v.visitEmptyStatement(this, d);
808 }
810 @Override
811 public Tag getTag() {
812 return SKIP;
813 }
814 }
816 /**
817 * A statement block.
818 * @param stats statements
819 * @param flags flags
820 */
821 public static class JCBlock extends JCStatement implements BlockTree {
822 public long flags;
823 public List<JCStatement> stats;
824 /** Position of closing brace, optional. */
825 public int endpos = Position.NOPOS;
826 protected JCBlock(long flags, List<JCStatement> stats) {
827 this.stats = stats;
828 this.flags = flags;
829 }
830 @Override
831 public void accept(Visitor v) { v.visitBlock(this); }
833 public Kind getKind() { return Kind.BLOCK; }
834 public List<JCStatement> getStatements() {
835 return stats;
836 }
837 public boolean isStatic() { return (flags & Flags.STATIC) != 0; }
838 @Override
839 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
840 return v.visitBlock(this, d);
841 }
843 @Override
844 public Tag getTag() {
845 return BLOCK;
846 }
847 }
849 /**
850 * A do loop
851 */
852 public static class JCDoWhileLoop extends JCStatement implements DoWhileLoopTree {
853 public JCStatement body;
854 public JCExpression cond;
855 protected JCDoWhileLoop(JCStatement body, JCExpression cond) {
856 this.body = body;
857 this.cond = cond;
858 }
859 @Override
860 public void accept(Visitor v) { v.visitDoLoop(this); }
862 public Kind getKind() { return Kind.DO_WHILE_LOOP; }
863 public JCExpression getCondition() { return cond; }
864 public JCStatement getStatement() { return body; }
865 @Override
866 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
867 return v.visitDoWhileLoop(this, d);
868 }
870 @Override
871 public Tag getTag() {
872 return DOLOOP;
873 }
874 }
876 /**
877 * A while loop
878 */
879 public static class JCWhileLoop extends JCStatement implements WhileLoopTree {
880 public JCExpression cond;
881 public JCStatement body;
882 protected JCWhileLoop(JCExpression cond, JCStatement body) {
883 this.cond = cond;
884 this.body = body;
885 }
886 @Override
887 public void accept(Visitor v) { v.visitWhileLoop(this); }
889 public Kind getKind() { return Kind.WHILE_LOOP; }
890 public JCExpression getCondition() { return cond; }
891 public JCStatement getStatement() { return body; }
892 @Override
893 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
894 return v.visitWhileLoop(this, d);
895 }
897 @Override
898 public Tag getTag() {
899 return WHILELOOP;
900 }
901 }
903 /**
904 * A for loop.
905 */
906 public static class JCForLoop extends JCStatement implements ForLoopTree {
907 public List<JCStatement> init;
908 public JCExpression cond;
909 public List<JCExpressionStatement> step;
910 public JCStatement body;
911 protected JCForLoop(List<JCStatement> init,
912 JCExpression cond,
913 List<JCExpressionStatement> update,
914 JCStatement body)
915 {
916 this.init = init;
917 this.cond = cond;
918 this.step = update;
919 this.body = body;
920 }
921 @Override
922 public void accept(Visitor v) { v.visitForLoop(this); }
924 public Kind getKind() { return Kind.FOR_LOOP; }
925 public JCExpression getCondition() { return cond; }
926 public JCStatement getStatement() { return body; }
927 public List<JCStatement> getInitializer() {
928 return init;
929 }
930 public List<JCExpressionStatement> getUpdate() {
931 return step;
932 }
933 @Override
934 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
935 return v.visitForLoop(this, d);
936 }
938 @Override
939 public Tag getTag() {
940 return FORLOOP;
941 }
942 }
944 /**
945 * The enhanced for loop.
946 */
947 public static class JCEnhancedForLoop extends JCStatement implements EnhancedForLoopTree {
948 public JCVariableDecl var;
949 public JCExpression expr;
950 public JCStatement body;
951 protected JCEnhancedForLoop(JCVariableDecl var, JCExpression expr, JCStatement body) {
952 this.var = var;
953 this.expr = expr;
954 this.body = body;
955 }
956 @Override
957 public void accept(Visitor v) { v.visitForeachLoop(this); }
959 public Kind getKind() { return Kind.ENHANCED_FOR_LOOP; }
960 public JCVariableDecl getVariable() { return var; }
961 public JCExpression getExpression() { return expr; }
962 public JCStatement getStatement() { return body; }
963 @Override
964 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
965 return v.visitEnhancedForLoop(this, d);
966 }
967 @Override
968 public Tag getTag() {
969 return FOREACHLOOP;
970 }
971 }
973 /**
974 * A labelled expression or statement.
975 */
976 public static class JCLabeledStatement extends JCStatement implements LabeledStatementTree {
977 public Name label;
978 public JCStatement body;
979 protected JCLabeledStatement(Name label, JCStatement body) {
980 this.label = label;
981 this.body = body;
982 }
983 @Override
984 public void accept(Visitor v) { v.visitLabelled(this); }
985 public Kind getKind() { return Kind.LABELED_STATEMENT; }
986 public Name getLabel() { return label; }
987 public JCStatement getStatement() { return body; }
988 @Override
989 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
990 return v.visitLabeledStatement(this, d);
991 }
992 @Override
993 public Tag getTag() {
994 return LABELLED;
995 }
996 }
998 /**
999 * A "switch ( ) { }" construction.
1000 */
1001 public static class JCSwitch extends JCStatement implements SwitchTree {
1002 public JCExpression selector;
1003 public List<JCCase> cases;
1004 protected JCSwitch(JCExpression selector, List<JCCase> cases) {
1005 this.selector = selector;
1006 this.cases = cases;
1007 }
1008 @Override
1009 public void accept(Visitor v) { v.visitSwitch(this); }
1011 public Kind getKind() { return Kind.SWITCH; }
1012 public JCExpression getExpression() { return selector; }
1013 public List<JCCase> getCases() { return cases; }
1014 @Override
1015 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1016 return v.visitSwitch(this, d);
1017 }
1018 @Override
1019 public Tag getTag() {
1020 return SWITCH;
1021 }
1022 }
1024 /**
1025 * A "case :" of a switch.
1026 */
1027 public static class JCCase extends JCStatement implements CaseTree {
1028 public JCExpression pat;
1029 public List<JCStatement> stats;
1030 protected JCCase(JCExpression pat, List<JCStatement> stats) {
1031 this.pat = pat;
1032 this.stats = stats;
1033 }
1034 @Override
1035 public void accept(Visitor v) { v.visitCase(this); }
1037 public Kind getKind() { return Kind.CASE; }
1038 public JCExpression getExpression() { return pat; }
1039 public List<JCStatement> getStatements() { return stats; }
1040 @Override
1041 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1042 return v.visitCase(this, d);
1043 }
1044 @Override
1045 public Tag getTag() {
1046 return CASE;
1047 }
1048 }
1050 /**
1051 * A synchronized block.
1052 */
1053 public static class JCSynchronized extends JCStatement implements SynchronizedTree {
1054 public JCExpression lock;
1055 public JCBlock body;
1056 protected JCSynchronized(JCExpression lock, JCBlock body) {
1057 this.lock = lock;
1058 this.body = body;
1059 }
1060 @Override
1061 public void accept(Visitor v) { v.visitSynchronized(this); }
1063 public Kind getKind() { return Kind.SYNCHRONIZED; }
1064 public JCExpression getExpression() { return lock; }
1065 public JCBlock getBlock() { return body; }
1066 @Override
1067 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1068 return v.visitSynchronized(this, d);
1069 }
1070 @Override
1071 public Tag getTag() {
1072 return SYNCHRONIZED;
1073 }
1074 }
1076 /**
1077 * A "try { } catch ( ) { } finally { }" block.
1078 */
1079 public static class JCTry extends JCStatement implements TryTree {
1080 public JCBlock body;
1081 public List<JCCatch> catchers;
1082 public JCBlock finalizer;
1083 public List<JCTree> resources;
1084 public boolean finallyCanCompleteNormally;
1085 protected JCTry(List<JCTree> resources,
1086 JCBlock body,
1087 List<JCCatch> catchers,
1088 JCBlock finalizer) {
1089 this.body = body;
1090 this.catchers = catchers;
1091 this.finalizer = finalizer;
1092 this.resources = resources;
1093 }
1094 @Override
1095 public void accept(Visitor v) { v.visitTry(this); }
1097 public Kind getKind() { return Kind.TRY; }
1098 public JCBlock getBlock() { return body; }
1099 public List<JCCatch> getCatches() {
1100 return catchers;
1101 }
1102 public JCBlock getFinallyBlock() { return finalizer; }
1103 @Override
1104 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1105 return v.visitTry(this, d);
1106 }
1107 @Override
1108 public List<? extends JCTree> getResources() {
1109 return resources;
1110 }
1111 @Override
1112 public Tag getTag() {
1113 return TRY;
1114 }
1115 }
1117 /**
1118 * A catch block.
1119 */
1120 public static class JCCatch extends JCTree implements CatchTree {
1121 public JCVariableDecl param;
1122 public JCBlock body;
1123 protected JCCatch(JCVariableDecl param, JCBlock body) {
1124 this.param = param;
1125 this.body = body;
1126 }
1127 @Override
1128 public void accept(Visitor v) { v.visitCatch(this); }
1130 public Kind getKind() { return Kind.CATCH; }
1131 public JCVariableDecl getParameter() { return param; }
1132 public JCBlock getBlock() { return body; }
1133 @Override
1134 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1135 return v.visitCatch(this, d);
1136 }
1137 @Override
1138 public Tag getTag() {
1139 return CATCH;
1140 }
1141 }
1143 /**
1144 * A ( ) ? ( ) : ( ) conditional expression
1145 */
1146 public static class JCConditional extends JCExpression implements ConditionalExpressionTree {
1147 public JCExpression cond;
1148 public JCExpression truepart;
1149 public JCExpression falsepart;
1150 protected JCConditional(JCExpression cond,
1151 JCExpression truepart,
1152 JCExpression falsepart)
1153 {
1154 this.cond = cond;
1155 this.truepart = truepart;
1156 this.falsepart = falsepart;
1157 }
1158 @Override
1159 public void accept(Visitor v) { v.visitConditional(this); }
1161 public Kind getKind() { return Kind.CONDITIONAL_EXPRESSION; }
1162 public JCExpression getCondition() { return cond; }
1163 public JCExpression getTrueExpression() { return truepart; }
1164 public JCExpression getFalseExpression() { return falsepart; }
1165 @Override
1166 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1167 return v.visitConditionalExpression(this, d);
1168 }
1169 @Override
1170 public Tag getTag() {
1171 return CONDEXPR;
1172 }
1173 }
1175 /**
1176 * An "if ( ) { } else { }" block
1177 */
1178 public static class JCIf extends JCStatement implements IfTree {
1179 public JCExpression cond;
1180 public JCStatement thenpart;
1181 public JCStatement elsepart;
1182 protected JCIf(JCExpression cond,
1183 JCStatement thenpart,
1184 JCStatement elsepart)
1185 {
1186 this.cond = cond;
1187 this.thenpart = thenpart;
1188 this.elsepart = elsepart;
1189 }
1190 @Override
1191 public void accept(Visitor v) { v.visitIf(this); }
1193 public Kind getKind() { return Kind.IF; }
1194 public JCExpression getCondition() { return cond; }
1195 public JCStatement getThenStatement() { return thenpart; }
1196 public JCStatement getElseStatement() { return elsepart; }
1197 @Override
1198 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1199 return v.visitIf(this, d);
1200 }
1201 @Override
1202 public Tag getTag() {
1203 return IF;
1204 }
1205 }
1207 /**
1208 * an expression statement
1209 * @param expr expression structure
1210 */
1211 public static class JCExpressionStatement extends JCStatement implements ExpressionStatementTree {
1212 public JCExpression expr;
1213 protected JCExpressionStatement(JCExpression expr)
1214 {
1215 this.expr = expr;
1216 }
1217 @Override
1218 public void accept(Visitor v) { v.visitExec(this); }
1220 public Kind getKind() { return Kind.EXPRESSION_STATEMENT; }
1221 public JCExpression getExpression() { return expr; }
1222 @Override
1223 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1224 return v.visitExpressionStatement(this, d);
1225 }
1226 @Override
1227 public Tag getTag() {
1228 return EXEC;
1229 }
1231 /** Convert a expression-statement tree to a pretty-printed string. */
1232 @Override
1233 public String toString() {
1234 StringWriter s = new StringWriter();
1235 try {
1236 new Pretty(s, false).printStat(this);
1237 }
1238 catch (IOException e) {
1239 // should never happen, because StringWriter is defined
1240 // never to throw any IOExceptions
1241 throw new AssertionError(e);
1242 }
1243 return s.toString();
1244 }
1245 }
1247 /**
1248 * A break from a loop or switch.
1249 */
1250 public static class JCBreak extends JCStatement implements BreakTree {
1251 public Name label;
1252 public JCTree target;
1253 protected JCBreak(Name label, JCTree target) {
1254 this.label = label;
1255 this.target = target;
1256 }
1257 @Override
1258 public void accept(Visitor v) { v.visitBreak(this); }
1260 public Kind getKind() { return Kind.BREAK; }
1261 public Name getLabel() { return label; }
1262 @Override
1263 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1264 return v.visitBreak(this, d);
1265 }
1266 @Override
1267 public Tag getTag() {
1268 return BREAK;
1269 }
1270 }
1272 /**
1273 * A continue of a loop.
1274 */
1275 public static class JCContinue extends JCStatement implements ContinueTree {
1276 public Name label;
1277 public JCTree target;
1278 protected JCContinue(Name label, JCTree target) {
1279 this.label = label;
1280 this.target = target;
1281 }
1282 @Override
1283 public void accept(Visitor v) { v.visitContinue(this); }
1285 public Kind getKind() { return Kind.CONTINUE; }
1286 public Name getLabel() { return label; }
1287 @Override
1288 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1289 return v.visitContinue(this, d);
1290 }
1291 @Override
1292 public Tag getTag() {
1293 return CONTINUE;
1294 }
1295 }
1297 /**
1298 * A return statement.
1299 */
1300 public static class JCReturn extends JCStatement implements ReturnTree {
1301 public JCExpression expr;
1302 protected JCReturn(JCExpression expr) {
1303 this.expr = expr;
1304 }
1305 @Override
1306 public void accept(Visitor v) { v.visitReturn(this); }
1308 public Kind getKind() { return Kind.RETURN; }
1309 public JCExpression getExpression() { return expr; }
1310 @Override
1311 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1312 return v.visitReturn(this, d);
1313 }
1314 @Override
1315 public Tag getTag() {
1316 return RETURN;
1317 }
1318 }
1320 /**
1321 * A throw statement.
1322 */
1323 public static class JCThrow extends JCStatement implements ThrowTree {
1324 public JCExpression expr;
1325 protected JCThrow(JCTree expr) {
1326 this.expr = (JCExpression)expr;
1327 }
1328 @Override
1329 public void accept(Visitor v) { v.visitThrow(this); }
1331 public Kind getKind() { return Kind.THROW; }
1332 public JCExpression getExpression() { return expr; }
1333 @Override
1334 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1335 return v.visitThrow(this, d);
1336 }
1337 @Override
1338 public Tag getTag() {
1339 return THROW;
1340 }
1341 }
1343 /**
1344 * An assert statement.
1345 */
1346 public static class JCAssert extends JCStatement implements AssertTree {
1347 public JCExpression cond;
1348 public JCExpression detail;
1349 protected JCAssert(JCExpression cond, JCExpression detail) {
1350 this.cond = cond;
1351 this.detail = detail;
1352 }
1353 @Override
1354 public void accept(Visitor v) { v.visitAssert(this); }
1356 public Kind getKind() { return Kind.ASSERT; }
1357 public JCExpression getCondition() { return cond; }
1358 public JCExpression getDetail() { return detail; }
1359 @Override
1360 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1361 return v.visitAssert(this, d);
1362 }
1363 @Override
1364 public Tag getTag() {
1365 return ASSERT;
1366 }
1367 }
1369 /**
1370 * A method invocation
1371 */
1372 public static class JCMethodInvocation extends JCExpression implements MethodInvocationTree {
1373 public List<JCExpression> typeargs;
1374 public JCExpression meth;
1375 public List<JCExpression> args;
1376 public Type varargsElement;
1377 protected JCMethodInvocation(List<JCExpression> typeargs,
1378 JCExpression meth,
1379 List<JCExpression> args)
1380 {
1381 this.typeargs = (typeargs == null) ? List.<JCExpression>nil()
1382 : typeargs;
1383 this.meth = meth;
1384 this.args = args;
1385 }
1386 @Override
1387 public void accept(Visitor v) { v.visitApply(this); }
1389 public Kind getKind() { return Kind.METHOD_INVOCATION; }
1390 public List<JCExpression> getTypeArguments() {
1391 return typeargs;
1392 }
1393 public JCExpression getMethodSelect() { return meth; }
1394 public List<JCExpression> getArguments() {
1395 return args;
1396 }
1397 @Override
1398 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1399 return v.visitMethodInvocation(this, d);
1400 }
1401 @Override
1402 public JCMethodInvocation setType(Type type) {
1403 super.setType(type);
1404 return this;
1405 }
1406 @Override
1407 public Tag getTag() {
1408 return(APPLY);
1409 }
1410 }
1412 /**
1413 * A new(...) operation.
1414 */
1415 public static class JCNewClass extends JCExpression implements NewClassTree {
1416 public JCExpression encl;
1417 public List<JCExpression> typeargs;
1418 public JCExpression clazz;
1419 public List<JCExpression> args;
1420 public JCClassDecl def;
1421 public Symbol constructor;
1422 public Type varargsElement;
1423 public Type constructorType;
1424 protected JCNewClass(JCExpression encl,
1425 List<JCExpression> typeargs,
1426 JCExpression clazz,
1427 List<JCExpression> args,
1428 JCClassDecl def)
1429 {
1430 this.encl = encl;
1431 this.typeargs = (typeargs == null) ? List.<JCExpression>nil()
1432 : typeargs;
1433 this.clazz = clazz;
1434 this.args = args;
1435 this.def = def;
1436 }
1437 @Override
1438 public void accept(Visitor v) { v.visitNewClass(this); }
1440 public Kind getKind() { return Kind.NEW_CLASS; }
1441 public JCExpression getEnclosingExpression() { // expr.new C< ... > ( ... )
1442 return encl;
1443 }
1444 public List<JCExpression> getTypeArguments() {
1445 return typeargs;
1446 }
1447 public JCExpression getIdentifier() { return clazz; }
1448 public List<JCExpression> getArguments() {
1449 return args;
1450 }
1451 public JCClassDecl getClassBody() { return def; }
1452 @Override
1453 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1454 return v.visitNewClass(this, d);
1455 }
1456 @Override
1457 public Tag getTag() {
1458 return NEWCLASS;
1459 }
1460 }
1462 /**
1463 * A new[...] operation.
1464 */
1465 public static class JCNewArray extends JCExpression implements NewArrayTree {
1466 public JCExpression elemtype;
1467 public List<JCExpression> dims;
1468 public List<JCExpression> elems;
1469 protected JCNewArray(JCExpression elemtype,
1470 List<JCExpression> dims,
1471 List<JCExpression> elems)
1472 {
1473 this.elemtype = elemtype;
1474 this.dims = dims;
1475 this.elems = elems;
1476 }
1477 @Override
1478 public void accept(Visitor v) { v.visitNewArray(this); }
1480 public Kind getKind() { return Kind.NEW_ARRAY; }
1481 public JCExpression getType() { return elemtype; }
1482 public List<JCExpression> getDimensions() {
1483 return dims;
1484 }
1485 public List<JCExpression> getInitializers() {
1486 return elems;
1487 }
1488 @Override
1489 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1490 return v.visitNewArray(this, d);
1491 }
1492 @Override
1493 public Tag getTag() {
1494 return NEWARRAY;
1495 }
1496 }
1498 /**
1499 * A lambda expression.
1500 */
1501 public static class JCLambda extends JCExpression implements LambdaExpressionTree {
1503 public List<JCVariableDecl> params;
1504 public JCTree body;
1505 public Type targetType;
1506 public boolean canCompleteNormally = true;
1507 public List<Type> inferredThrownTypes;
1509 public JCLambda(List<JCVariableDecl> params,
1510 JCTree body) {
1511 this.params = params;
1512 this.body = body;
1513 }
1514 @Override
1515 public Tag getTag() {
1516 return LAMBDA;
1517 }
1518 @Override
1519 public void accept(Visitor v) {
1520 v.visitLambda(this);
1521 }
1522 @Override
1523 public <R, D> R accept(TreeVisitor<R, D> v, D d) {
1524 return v.visitLambdaExpression(this, d);
1525 }
1526 public Kind getKind() {
1527 return Kind.LAMBDA_EXPRESSION;
1528 }
1529 public JCTree getBody() {
1530 return body;
1531 }
1532 public java.util.List<? extends VariableTree> getParameters() {
1533 return params;
1534 }
1535 @Override
1536 public JCLambda setType(Type type) {
1537 super.setType(type);
1538 return this;
1539 }
1540 @Override
1541 public BodyKind getBodyKind() {
1542 return body.hasTag(BLOCK) ?
1543 BodyKind.STATEMENT :
1544 BodyKind.EXPRESSION;
1545 }
1546 }
1548 /**
1549 * A parenthesized subexpression ( ... )
1550 */
1551 public static class JCParens extends JCExpression implements ParenthesizedTree {
1552 public JCExpression expr;
1553 protected JCParens(JCExpression expr) {
1554 this.expr = expr;
1555 }
1556 @Override
1557 public void accept(Visitor v) { v.visitParens(this); }
1559 public Kind getKind() { return Kind.PARENTHESIZED; }
1560 public JCExpression getExpression() { return expr; }
1561 @Override
1562 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1563 return v.visitParenthesized(this, d);
1564 }
1565 @Override
1566 public Tag getTag() {
1567 return PARENS;
1568 }
1569 }
1571 /**
1572 * A assignment with "=".
1573 */
1574 public static class JCAssign extends JCExpression implements AssignmentTree {
1575 public JCExpression lhs;
1576 public JCExpression rhs;
1577 protected JCAssign(JCExpression lhs, JCExpression rhs) {
1578 this.lhs = lhs;
1579 this.rhs = rhs;
1580 }
1581 @Override
1582 public void accept(Visitor v) { v.visitAssign(this); }
1584 public Kind getKind() { return Kind.ASSIGNMENT; }
1585 public JCExpression getVariable() { return lhs; }
1586 public JCExpression getExpression() { return rhs; }
1587 @Override
1588 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1589 return v.visitAssignment(this, d);
1590 }
1591 @Override
1592 public Tag getTag() {
1593 return ASSIGN;
1594 }
1595 }
1597 /**
1598 * An assignment with "+=", "|=" ...
1599 */
1600 public static class JCAssignOp extends JCExpression implements CompoundAssignmentTree {
1601 private Tag opcode;
1602 public JCExpression lhs;
1603 public JCExpression rhs;
1604 public Symbol operator;
1605 protected JCAssignOp(Tag opcode, JCTree lhs, JCTree rhs, Symbol operator) {
1606 this.opcode = opcode;
1607 this.lhs = (JCExpression)lhs;
1608 this.rhs = (JCExpression)rhs;
1609 this.operator = operator;
1610 }
1611 @Override
1612 public void accept(Visitor v) { v.visitAssignop(this); }
1614 public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
1615 public JCExpression getVariable() { return lhs; }
1616 public JCExpression getExpression() { return rhs; }
1617 public Symbol getOperator() {
1618 return operator;
1619 }
1620 @Override
1621 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1622 return v.visitCompoundAssignment(this, d);
1623 }
1624 @Override
1625 public Tag getTag() {
1626 return opcode;
1627 }
1628 }
1630 /**
1631 * A unary operation.
1632 */
1633 public static class JCUnary extends JCExpression implements UnaryTree {
1634 private Tag opcode;
1635 public JCExpression arg;
1636 public Symbol operator;
1637 protected JCUnary(Tag opcode, JCExpression arg) {
1638 this.opcode = opcode;
1639 this.arg = arg;
1640 }
1641 @Override
1642 public void accept(Visitor v) { v.visitUnary(this); }
1644 public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
1645 public JCExpression getExpression() { return arg; }
1646 public Symbol getOperator() {
1647 return operator;
1648 }
1649 @Override
1650 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1651 return v.visitUnary(this, d);
1652 }
1653 @Override
1654 public Tag getTag() {
1655 return opcode;
1656 }
1658 public void setTag(Tag tag) {
1659 opcode = tag;
1660 }
1661 }
1663 /**
1664 * A binary operation.
1665 */
1666 public static class JCBinary extends JCExpression implements BinaryTree {
1667 private Tag opcode;
1668 public JCExpression lhs;
1669 public JCExpression rhs;
1670 public Symbol operator;
1671 protected JCBinary(Tag opcode,
1672 JCExpression lhs,
1673 JCExpression rhs,
1674 Symbol operator) {
1675 this.opcode = opcode;
1676 this.lhs = lhs;
1677 this.rhs = rhs;
1678 this.operator = operator;
1679 }
1680 @Override
1681 public void accept(Visitor v) { v.visitBinary(this); }
1683 public Kind getKind() { return TreeInfo.tagToKind(getTag()); }
1684 public JCExpression getLeftOperand() { return lhs; }
1685 public JCExpression getRightOperand() { return rhs; }
1686 public Symbol getOperator() {
1687 return operator;
1688 }
1689 @Override
1690 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1691 return v.visitBinary(this, d);
1692 }
1693 @Override
1694 public Tag getTag() {
1695 return opcode;
1696 }
1697 }
1699 /**
1700 * A type cast.
1701 */
1702 public static class JCTypeCast extends JCExpression implements TypeCastTree {
1703 public JCTree clazz;
1704 public JCExpression expr;
1705 protected JCTypeCast(JCTree clazz, JCExpression expr) {
1706 this.clazz = clazz;
1707 this.expr = expr;
1708 }
1709 @Override
1710 public void accept(Visitor v) { v.visitTypeCast(this); }
1712 public Kind getKind() { return Kind.TYPE_CAST; }
1713 public JCTree getType() { return clazz; }
1714 public JCExpression getExpression() { return expr; }
1715 @Override
1716 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1717 return v.visitTypeCast(this, d);
1718 }
1719 @Override
1720 public Tag getTag() {
1721 return TYPECAST;
1722 }
1723 }
1725 /**
1726 * A type test.
1727 */
1728 public static class JCInstanceOf extends JCExpression implements InstanceOfTree {
1729 public JCExpression expr;
1730 public JCTree clazz;
1731 protected JCInstanceOf(JCExpression expr, JCTree clazz) {
1732 this.expr = expr;
1733 this.clazz = clazz;
1734 }
1735 @Override
1736 public void accept(Visitor v) { v.visitTypeTest(this); }
1738 public Kind getKind() { return Kind.INSTANCE_OF; }
1739 public JCTree getType() { return clazz; }
1740 public JCExpression getExpression() { return expr; }
1741 @Override
1742 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1743 return v.visitInstanceOf(this, d);
1744 }
1745 @Override
1746 public Tag getTag() {
1747 return TYPETEST;
1748 }
1749 }
1751 /**
1752 * An array selection
1753 */
1754 public static class JCArrayAccess extends JCExpression implements ArrayAccessTree {
1755 public JCExpression indexed;
1756 public JCExpression index;
1757 protected JCArrayAccess(JCExpression indexed, JCExpression index) {
1758 this.indexed = indexed;
1759 this.index = index;
1760 }
1761 @Override
1762 public void accept(Visitor v) { v.visitIndexed(this); }
1764 public Kind getKind() { return Kind.ARRAY_ACCESS; }
1765 public JCExpression getExpression() { return indexed; }
1766 public JCExpression getIndex() { return index; }
1767 @Override
1768 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1769 return v.visitArrayAccess(this, d);
1770 }
1771 @Override
1772 public Tag getTag() {
1773 return INDEXED;
1774 }
1775 }
1777 /**
1778 * Selects through packages and classes
1779 * @param selected selected Tree hierarchie
1780 * @param selector name of field to select thru
1781 * @param sym symbol of the selected class
1782 */
1783 public static class JCFieldAccess extends JCExpression implements MemberSelectTree {
1784 public JCExpression selected;
1785 public Name name;
1786 public Symbol sym;
1787 protected JCFieldAccess(JCExpression selected, Name name, Symbol sym) {
1788 this.selected = selected;
1789 this.name = name;
1790 this.sym = sym;
1791 }
1792 @Override
1793 public void accept(Visitor v) { v.visitSelect(this); }
1795 public Kind getKind() { return Kind.MEMBER_SELECT; }
1796 public JCExpression getExpression() { return selected; }
1797 @Override
1798 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1799 return v.visitMemberSelect(this, d);
1800 }
1801 public Name getIdentifier() { return name; }
1802 @Override
1803 public Tag getTag() {
1804 return SELECT;
1805 }
1806 }
1808 /**
1809 * Selects a member expression.
1810 */
1811 public static class JCMemberReference extends JCExpression implements MemberReferenceTree {
1812 public ReferenceMode mode;
1813 public Name name;
1814 public JCExpression expr;
1815 public List<JCExpression> typeargs;
1816 public Type targetType;
1817 public Symbol sym;
1819 protected JCMemberReference(ReferenceMode mode, Name name, JCExpression expr, List<JCExpression> typeargs) {
1820 this.mode = mode;
1821 this.name = name;
1822 this.expr = expr;
1823 this.typeargs = typeargs;
1824 }
1825 @Override
1826 public void accept(Visitor v) { v.visitReference(this); }
1828 public Kind getKind() { return Kind.MEMBER_REFERENCE; }
1829 @Override
1830 public ReferenceMode getMode() { return mode; }
1831 @Override
1832 public JCExpression getQualifierExpression() { return expr; }
1833 @Override
1834 public Name getName() { return name; }
1835 @Override
1836 public List<JCExpression> getTypeArguments() { return typeargs; }
1838 @Override
1839 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1840 return v.visitMemberReference(this, d);
1841 }
1842 @Override
1843 public Tag getTag() {
1844 return REFERENCE;
1845 }
1846 }
1848 /**
1849 * An identifier
1850 * @param idname the name
1851 * @param sym the symbol
1852 */
1853 public static class JCIdent extends JCExpression implements IdentifierTree {
1854 public Name name;
1855 public Symbol sym;
1856 protected JCIdent(Name name, Symbol sym) {
1857 this.name = name;
1858 this.sym = sym;
1859 }
1860 @Override
1861 public void accept(Visitor v) { v.visitIdent(this); }
1863 public Kind getKind() { return Kind.IDENTIFIER; }
1864 public Name getName() { return name; }
1865 @Override
1866 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1867 return v.visitIdentifier(this, d);
1868 }
1869 @Override
1870 public Tag getTag() {
1871 return IDENT;
1872 }
1873 }
1875 /**
1876 * A constant value given literally.
1877 * @param value value representation
1878 */
1879 public static class JCLiteral extends JCExpression implements LiteralTree {
1880 public int typetag;
1881 public Object value;
1882 protected JCLiteral(int typetag, Object value) {
1883 this.typetag = typetag;
1884 this.value = value;
1885 }
1886 @Override
1887 public void accept(Visitor v) { v.visitLiteral(this); }
1889 public Kind getKind() {
1890 switch (typetag) {
1891 case TypeTags.INT:
1892 return Kind.INT_LITERAL;
1893 case TypeTags.LONG:
1894 return Kind.LONG_LITERAL;
1895 case TypeTags.FLOAT:
1896 return Kind.FLOAT_LITERAL;
1897 case TypeTags.DOUBLE:
1898 return Kind.DOUBLE_LITERAL;
1899 case TypeTags.BOOLEAN:
1900 return Kind.BOOLEAN_LITERAL;
1901 case TypeTags.CHAR:
1902 return Kind.CHAR_LITERAL;
1903 case TypeTags.CLASS:
1904 return Kind.STRING_LITERAL;
1905 case TypeTags.BOT:
1906 return Kind.NULL_LITERAL;
1907 default:
1908 throw new AssertionError("unknown literal kind " + this);
1909 }
1910 }
1911 public Object getValue() {
1912 switch (typetag) {
1913 case TypeTags.BOOLEAN:
1914 int bi = (Integer) value;
1915 return (bi != 0);
1916 case TypeTags.CHAR:
1917 int ci = (Integer) value;
1918 char c = (char) ci;
1919 if (c != ci)
1920 throw new AssertionError("bad value for char literal");
1921 return c;
1922 default:
1923 return value;
1924 }
1925 }
1926 @Override
1927 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1928 return v.visitLiteral(this, d);
1929 }
1930 @Override
1931 public JCLiteral setType(Type type) {
1932 super.setType(type);
1933 return this;
1934 }
1935 @Override
1936 public Tag getTag() {
1937 return LITERAL;
1938 }
1939 }
1941 /**
1942 * Identifies a basic type.
1943 * @param tag the basic type id
1944 * @see TypeTags
1945 */
1946 public static class JCPrimitiveTypeTree extends JCExpression implements PrimitiveTypeTree {
1947 public int typetag;
1948 protected JCPrimitiveTypeTree(int typetag) {
1949 this.typetag = typetag;
1950 }
1951 @Override
1952 public void accept(Visitor v) { v.visitTypeIdent(this); }
1954 public Kind getKind() { return Kind.PRIMITIVE_TYPE; }
1955 public TypeKind getPrimitiveTypeKind() {
1956 switch (typetag) {
1957 case TypeTags.BOOLEAN:
1958 return TypeKind.BOOLEAN;
1959 case TypeTags.BYTE:
1960 return TypeKind.BYTE;
1961 case TypeTags.SHORT:
1962 return TypeKind.SHORT;
1963 case TypeTags.INT:
1964 return TypeKind.INT;
1965 case TypeTags.LONG:
1966 return TypeKind.LONG;
1967 case TypeTags.CHAR:
1968 return TypeKind.CHAR;
1969 case TypeTags.FLOAT:
1970 return TypeKind.FLOAT;
1971 case TypeTags.DOUBLE:
1972 return TypeKind.DOUBLE;
1973 case TypeTags.VOID:
1974 return TypeKind.VOID;
1975 default:
1976 throw new AssertionError("unknown primitive type " + this);
1977 }
1978 }
1979 @Override
1980 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
1981 return v.visitPrimitiveType(this, d);
1982 }
1983 @Override
1984 public Tag getTag() {
1985 return TYPEIDENT;
1986 }
1987 }
1989 /**
1990 * An array type, A[]
1991 */
1992 public static class JCArrayTypeTree extends JCExpression implements ArrayTypeTree {
1993 public JCExpression elemtype;
1994 protected JCArrayTypeTree(JCExpression elemtype) {
1995 this.elemtype = elemtype;
1996 }
1997 @Override
1998 public void accept(Visitor v) { v.visitTypeArray(this); }
2000 public Kind getKind() { return Kind.ARRAY_TYPE; }
2001 public JCTree getType() { return elemtype; }
2002 @Override
2003 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2004 return v.visitArrayType(this, d);
2005 }
2006 @Override
2007 public Tag getTag() {
2008 return TYPEARRAY;
2009 }
2010 }
2012 /**
2013 * A parameterized type, {@literal T<...>}
2014 */
2015 public static class JCTypeApply extends JCExpression implements ParameterizedTypeTree {
2016 public JCExpression clazz;
2017 public List<JCExpression> arguments;
2018 protected JCTypeApply(JCExpression clazz, List<JCExpression> arguments) {
2019 this.clazz = clazz;
2020 this.arguments = arguments;
2021 }
2022 @Override
2023 public void accept(Visitor v) { v.visitTypeApply(this); }
2025 public Kind getKind() { return Kind.PARAMETERIZED_TYPE; }
2026 public JCTree getType() { return clazz; }
2027 public List<JCExpression> getTypeArguments() {
2028 return arguments;
2029 }
2030 @Override
2031 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2032 return v.visitParameterizedType(this, d);
2033 }
2034 @Override
2035 public Tag getTag() {
2036 return TYPEAPPLY;
2037 }
2038 }
2040 /**
2041 * A union type, T1 | T2 | ... Tn (used in multicatch statements)
2042 */
2043 public static class JCTypeUnion extends JCExpression implements UnionTypeTree {
2045 public List<JCExpression> alternatives;
2047 protected JCTypeUnion(List<JCExpression> components) {
2048 this.alternatives = components;
2049 }
2050 @Override
2051 public void accept(Visitor v) { v.visitTypeUnion(this); }
2053 public Kind getKind() { return Kind.UNION_TYPE; }
2055 public List<JCExpression> getTypeAlternatives() {
2056 return alternatives;
2057 }
2058 @Override
2059 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2060 return v.visitUnionType(this, d);
2061 }
2062 @Override
2063 public Tag getTag() {
2064 return TYPEUNION;
2065 }
2066 }
2068 /**
2069 * A formal class parameter.
2070 * @param name name
2071 * @param bounds bounds
2072 */
2073 public static class JCTypeParameter extends JCTree implements TypeParameterTree {
2074 public Name name;
2075 public List<JCExpression> bounds;
2076 protected JCTypeParameter(Name name, List<JCExpression> bounds) {
2077 this.name = name;
2078 this.bounds = bounds;
2079 }
2080 @Override
2081 public void accept(Visitor v) { v.visitTypeParameter(this); }
2083 public Kind getKind() { return Kind.TYPE_PARAMETER; }
2084 public Name getName() { return name; }
2085 public List<JCExpression> getBounds() {
2086 return bounds;
2087 }
2088 @Override
2089 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2090 return v.visitTypeParameter(this, d);
2091 }
2092 @Override
2093 public Tag getTag() {
2094 return TYPEPARAMETER;
2095 }
2096 }
2098 public static class JCWildcard extends JCExpression implements WildcardTree {
2099 public TypeBoundKind kind;
2100 public JCTree inner;
2101 protected JCWildcard(TypeBoundKind kind, JCTree inner) {
2102 kind.getClass(); // null-check
2103 this.kind = kind;
2104 this.inner = inner;
2105 }
2106 @Override
2107 public void accept(Visitor v) { v.visitWildcard(this); }
2109 public Kind getKind() {
2110 switch (kind.kind) {
2111 case UNBOUND:
2112 return Kind.UNBOUNDED_WILDCARD;
2113 case EXTENDS:
2114 return Kind.EXTENDS_WILDCARD;
2115 case SUPER:
2116 return Kind.SUPER_WILDCARD;
2117 default:
2118 throw new AssertionError("Unknown wildcard bound " + kind);
2119 }
2120 }
2121 public JCTree getBound() { return inner; }
2122 @Override
2123 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2124 return v.visitWildcard(this, d);
2125 }
2126 @Override
2127 public Tag getTag() {
2128 return WILDCARD;
2129 }
2130 }
2132 public static class TypeBoundKind extends JCTree {
2133 public BoundKind kind;
2134 protected TypeBoundKind(BoundKind kind) {
2135 this.kind = kind;
2136 }
2137 @Override
2138 public void accept(Visitor v) { v.visitTypeBoundKind(this); }
2140 public Kind getKind() {
2141 throw new AssertionError("TypeBoundKind is not part of a public API");
2142 }
2143 @Override
2144 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2145 throw new AssertionError("TypeBoundKind is not part of a public API");
2146 }
2147 @Override
2148 public Tag getTag() {
2149 return TYPEBOUNDKIND;
2150 }
2151 }
2153 public static class JCAnnotation extends JCExpression implements AnnotationTree {
2154 public JCTree annotationType;
2155 public List<JCExpression> args;
2156 protected JCAnnotation(JCTree annotationType, List<JCExpression> args) {
2157 this.annotationType = annotationType;
2158 this.args = args;
2159 }
2160 @Override
2161 public void accept(Visitor v) { v.visitAnnotation(this); }
2163 public Kind getKind() { return Kind.ANNOTATION; }
2164 public JCTree getAnnotationType() { return annotationType; }
2165 public List<JCExpression> getArguments() {
2166 return args;
2167 }
2168 @Override
2169 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2170 return v.visitAnnotation(this, d);
2171 }
2172 @Override
2173 public Tag getTag() {
2174 return ANNOTATION;
2175 }
2176 }
2178 public static class JCModifiers extends JCTree implements com.sun.source.tree.ModifiersTree {
2179 public long flags;
2180 public List<JCAnnotation> annotations;
2181 protected JCModifiers(long flags, List<JCAnnotation> annotations) {
2182 this.flags = flags;
2183 this.annotations = annotations;
2184 }
2185 @Override
2186 public void accept(Visitor v) { v.visitModifiers(this); }
2188 public Kind getKind() { return Kind.MODIFIERS; }
2189 public Set<Modifier> getFlags() {
2190 return Flags.asModifierSet(flags);
2191 }
2192 public List<JCAnnotation> getAnnotations() {
2193 return annotations;
2194 }
2195 @Override
2196 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2197 return v.visitModifiers(this, d);
2198 }
2199 @Override
2200 public Tag getTag() {
2201 return MODIFIERS;
2202 }
2203 }
2205 public static class JCErroneous extends JCExpression
2206 implements com.sun.source.tree.ErroneousTree {
2207 public List<? extends JCTree> errs;
2208 protected JCErroneous(List<? extends JCTree> errs) {
2209 this.errs = errs;
2210 }
2211 @Override
2212 public void accept(Visitor v) { v.visitErroneous(this); }
2214 public Kind getKind() { return Kind.ERRONEOUS; }
2216 public List<? extends JCTree> getErrorTrees() {
2217 return errs;
2218 }
2220 @Override
2221 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2222 return v.visitErroneous(this, d);
2223 }
2224 @Override
2225 public Tag getTag() {
2226 return ERRONEOUS;
2227 }
2228 }
2230 /** (let int x = 3; in x+2) */
2231 public static class LetExpr extends JCExpression {
2232 public List<JCVariableDecl> defs;
2233 public JCTree expr;
2234 protected LetExpr(List<JCVariableDecl> defs, JCTree expr) {
2235 this.defs = defs;
2236 this.expr = expr;
2237 }
2238 @Override
2239 public void accept(Visitor v) { v.visitLetExpr(this); }
2241 public Kind getKind() {
2242 throw new AssertionError("LetExpr is not part of a public API");
2243 }
2244 @Override
2245 public <R,D> R accept(TreeVisitor<R,D> v, D d) {
2246 throw new AssertionError("LetExpr is not part of a public API");
2247 }
2248 @Override
2249 public Tag getTag() {
2250 return LETEXPR;
2251 }
2252 }
2254 /** An interface for tree factories
2255 */
2256 public interface Factory {
2257 JCCompilationUnit TopLevel(List<JCAnnotation> packageAnnotations,
2258 JCExpression pid,
2259 List<JCTree> defs);
2260 JCImport Import(JCTree qualid, boolean staticImport);
2261 JCClassDecl ClassDef(JCModifiers mods,
2262 Name name,
2263 List<JCTypeParameter> typarams,
2264 JCExpression extending,
2265 List<JCExpression> implementing,
2266 List<JCTree> defs);
2267 JCMethodDecl MethodDef(JCModifiers mods,
2268 Name name,
2269 JCExpression restype,
2270 List<JCTypeParameter> typarams,
2271 List<JCVariableDecl> params,
2272 List<JCExpression> thrown,
2273 JCBlock body,
2274 JCExpression defaultValue);
2275 JCVariableDecl VarDef(JCModifiers mods,
2276 Name name,
2277 JCExpression vartype,
2278 JCExpression init);
2279 JCSkip Skip();
2280 JCBlock Block(long flags, List<JCStatement> stats);
2281 JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond);
2282 JCWhileLoop WhileLoop(JCExpression cond, JCStatement body);
2283 JCForLoop ForLoop(List<JCStatement> init,
2284 JCExpression cond,
2285 List<JCExpressionStatement> step,
2286 JCStatement body);
2287 JCEnhancedForLoop ForeachLoop(JCVariableDecl var, JCExpression expr, JCStatement body);
2288 JCLabeledStatement Labelled(Name label, JCStatement body);
2289 JCSwitch Switch(JCExpression selector, List<JCCase> cases);
2290 JCCase Case(JCExpression pat, List<JCStatement> stats);
2291 JCSynchronized Synchronized(JCExpression lock, JCBlock body);
2292 JCTry Try(JCBlock body, List<JCCatch> catchers, JCBlock finalizer);
2293 JCTry Try(List<JCTree> resources,
2294 JCBlock body,
2295 List<JCCatch> catchers,
2296 JCBlock finalizer);
2297 JCCatch Catch(JCVariableDecl param, JCBlock body);
2298 JCConditional Conditional(JCExpression cond,
2299 JCExpression thenpart,
2300 JCExpression elsepart);
2301 JCIf If(JCExpression cond, JCStatement thenpart, JCStatement elsepart);
2302 JCExpressionStatement Exec(JCExpression expr);
2303 JCBreak Break(Name label);
2304 JCContinue Continue(Name label);
2305 JCReturn Return(JCExpression expr);
2306 JCThrow Throw(JCTree expr);
2307 JCAssert Assert(JCExpression cond, JCExpression detail);
2308 JCMethodInvocation Apply(List<JCExpression> typeargs,
2309 JCExpression fn,
2310 List<JCExpression> args);
2311 JCNewClass NewClass(JCExpression encl,
2312 List<JCExpression> typeargs,
2313 JCExpression clazz,
2314 List<JCExpression> args,
2315 JCClassDecl def);
2316 JCNewArray NewArray(JCExpression elemtype,
2317 List<JCExpression> dims,
2318 List<JCExpression> elems);
2319 JCParens Parens(JCExpression expr);
2320 JCAssign Assign(JCExpression lhs, JCExpression rhs);
2321 JCAssignOp Assignop(Tag opcode, JCTree lhs, JCTree rhs);
2322 JCUnary Unary(Tag opcode, JCExpression arg);
2323 JCBinary Binary(Tag opcode, JCExpression lhs, JCExpression rhs);
2324 JCTypeCast TypeCast(JCTree expr, JCExpression type);
2325 JCInstanceOf TypeTest(JCExpression expr, JCTree clazz);
2326 JCArrayAccess Indexed(JCExpression indexed, JCExpression index);
2327 JCFieldAccess Select(JCExpression selected, Name selector);
2328 JCIdent Ident(Name idname);
2329 JCLiteral Literal(int tag, Object value);
2330 JCPrimitiveTypeTree TypeIdent(int typetag);
2331 JCArrayTypeTree TypeArray(JCExpression elemtype);
2332 JCTypeApply TypeApply(JCExpression clazz, List<JCExpression> arguments);
2333 JCTypeParameter TypeParameter(Name name, List<JCExpression> bounds);
2334 JCWildcard Wildcard(TypeBoundKind kind, JCTree type);
2335 TypeBoundKind TypeBoundKind(BoundKind kind);
2336 JCAnnotation Annotation(JCTree annotationType, List<JCExpression> args);
2337 JCModifiers Modifiers(long flags, List<JCAnnotation> annotations);
2338 JCErroneous Erroneous(List<? extends JCTree> errs);
2339 LetExpr LetExpr(List<JCVariableDecl> defs, JCTree expr);
2340 }
2342 /** A generic visitor class for trees.
2343 */
2344 public static abstract class Visitor {
2345 public void visitTopLevel(JCCompilationUnit that) { visitTree(that); }
2346 public void visitImport(JCImport that) { visitTree(that); }
2347 public void visitClassDef(JCClassDecl that) { visitTree(that); }
2348 public void visitMethodDef(JCMethodDecl that) { visitTree(that); }
2349 public void visitVarDef(JCVariableDecl that) { visitTree(that); }
2350 public void visitSkip(JCSkip that) { visitTree(that); }
2351 public void visitBlock(JCBlock that) { visitTree(that); }
2352 public void visitDoLoop(JCDoWhileLoop that) { visitTree(that); }
2353 public void visitWhileLoop(JCWhileLoop that) { visitTree(that); }
2354 public void visitForLoop(JCForLoop that) { visitTree(that); }
2355 public void visitForeachLoop(JCEnhancedForLoop that) { visitTree(that); }
2356 public void visitLabelled(JCLabeledStatement that) { visitTree(that); }
2357 public void visitSwitch(JCSwitch that) { visitTree(that); }
2358 public void visitCase(JCCase that) { visitTree(that); }
2359 public void visitSynchronized(JCSynchronized that) { visitTree(that); }
2360 public void visitTry(JCTry that) { visitTree(that); }
2361 public void visitCatch(JCCatch that) { visitTree(that); }
2362 public void visitConditional(JCConditional that) { visitTree(that); }
2363 public void visitIf(JCIf that) { visitTree(that); }
2364 public void visitExec(JCExpressionStatement that) { visitTree(that); }
2365 public void visitBreak(JCBreak that) { visitTree(that); }
2366 public void visitContinue(JCContinue that) { visitTree(that); }
2367 public void visitReturn(JCReturn that) { visitTree(that); }
2368 public void visitThrow(JCThrow that) { visitTree(that); }
2369 public void visitAssert(JCAssert that) { visitTree(that); }
2370 public void visitApply(JCMethodInvocation that) { visitTree(that); }
2371 public void visitNewClass(JCNewClass that) { visitTree(that); }
2372 public void visitNewArray(JCNewArray that) { visitTree(that); }
2373 public void visitLambda(JCLambda that) { visitTree(that); }
2374 public void visitParens(JCParens that) { visitTree(that); }
2375 public void visitAssign(JCAssign that) { visitTree(that); }
2376 public void visitAssignop(JCAssignOp that) { visitTree(that); }
2377 public void visitUnary(JCUnary that) { visitTree(that); }
2378 public void visitBinary(JCBinary that) { visitTree(that); }
2379 public void visitTypeCast(JCTypeCast that) { visitTree(that); }
2380 public void visitTypeTest(JCInstanceOf that) { visitTree(that); }
2381 public void visitIndexed(JCArrayAccess that) { visitTree(that); }
2382 public void visitSelect(JCFieldAccess that) { visitTree(that); }
2383 public void visitReference(JCMemberReference that) { visitTree(that); }
2384 public void visitIdent(JCIdent that) { visitTree(that); }
2385 public void visitLiteral(JCLiteral that) { visitTree(that); }
2386 public void visitTypeIdent(JCPrimitiveTypeTree that) { visitTree(that); }
2387 public void visitTypeArray(JCArrayTypeTree that) { visitTree(that); }
2388 public void visitTypeApply(JCTypeApply that) { visitTree(that); }
2389 public void visitTypeUnion(JCTypeUnion that) { visitTree(that); }
2390 public void visitTypeParameter(JCTypeParameter that) { visitTree(that); }
2391 public void visitWildcard(JCWildcard that) { visitTree(that); }
2392 public void visitTypeBoundKind(TypeBoundKind that) { visitTree(that); }
2393 public void visitAnnotation(JCAnnotation that) { visitTree(that); }
2394 public void visitModifiers(JCModifiers that) { visitTree(that); }
2395 public void visitErroneous(JCErroneous that) { visitTree(that); }
2396 public void visitLetExpr(LetExpr that) { visitTree(that); }
2398 public void visitTree(JCTree that) { Assert.error(); }
2399 }
2401 }