Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/tree/JCTree.java

src/share/classes/com/sun/tools/javac/tree/JCTree.java

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

Mercurial Repository: jdk8-mips64-public/langtools

mercurial