jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/comp/Flow.java

equal deleted inserted replaced

-:42f7cc0468dd
+:e87b50888909
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import static com.sun.tools.javac.code.Flags.*;
+import static com.sun.tools.javac.code.Flags.BLOCK;
 import static com.sun.tools.javac.code.Kinds.*;
 import static com.sun.tools.javac.code.TypeTags.*;
+import static com.sun.tools.javac.tree.JCTree.Tag.*;
 /** This pass implements dataflow analysis for Java programs.
 *  Liveness analysis checks that every statement is reachable.
 *  Exception analysis ensures that every checked exception that is
 *  thrown is declared or caught.  Definite assignment analysis
 if (classDef != null &&
 classDef.pos == exit.tree.pos) {
 log.error(exit.tree.pos(),
 "unreported.exception.default.constructor",
 exit.thrown);
-} else if (exit.tree.getTag() == JCTree.VARDEF &&
+} else if (exit.tree.hasTag(VARDEF) &&
 ((JCVariableDecl)exit.tree).sym.isResourceVariable()) {
 log.error(exit.tree.pos(),
 "unreported.exception.implicit.close",
 exit.thrown,
 ((JCVariableDecl)exit.tree).sym.name);
 *  C.this.name, and tree represents a trackable variable,
 *  record an initialization of the variable.
 */
 void letInit(JCTree tree) {
 tree = TreeInfo.skipParens(tree);
-if (tree.getTag() == JCTree.IDENT || tree.getTag() == JCTree.SELECT) {
+if (tree.hasTag(IDENT) || tree.hasTag(SELECT)) {
 Symbol sym = TreeInfo.symbol(tree);
 if (sym.kind == VAR) {
 letInit(tree.pos(), (VarSymbol)sym);
 }
 }
 boolean result = false;
 List<PendingExit> exits = pendingExits.toList();
 pendingExits = oldPendingExits;
 for (; exits.nonEmpty(); exits = exits.tail) {
 PendingExit exit = exits.head;
-if (exit.tree.getTag() == JCTree.BREAK &&
+if (exit.tree.hasTag(BREAK) &&
 ((JCBreak) exit.tree).target == tree) {
 inits.andSet(exit.inits);
 uninits.andSet(exit.uninits);
 result = true;
 } else {
 boolean result = false;
 List<PendingExit> exits = pendingExits.toList();
 pendingExits = new ListBuffer<PendingExit>();
 for (; exits.nonEmpty(); exits = exits.tail) {
 PendingExit exit = exits.head;
-if (exit.tree.getTag() == JCTree.CONTINUE &&
+if (exit.tree.hasTag(CONTINUE) &&
 ((JCContinue) exit.tree).target == tree) {
 inits.andSet(exit.inits);
 uninits.andSet(exit.uninits);
 result = true;
 } else {
 /** Analyze a definition.
 */
 void scanDef(JCTree tree) {
 scanStat(tree);
-if (tree != null && tree.getTag() == JCTree.BLOCK && !alive) {
+if (tree != null && tree.hasTag(JCTree.Tag.BLOCK) && !alive) {
 log.error(tree.pos(),
 "initializer.must.be.able.to.complete.normally");
 }
 }
 /** Analyze a statement. Check that statement is reachable.
 */
 void scanStat(JCTree tree) {
 if (!alive && tree != null) {
 log.error(tree.pos(), "unreachable.stmt");
-if (tree.getTag() != JCTree.SKIP) alive = true;
+if (!tree.hasTag(SKIP)) alive = true;
 }
 scan(tree);
 }
 /** Analyze list of statements.
 lint = lint.augment(tree.sym.attributes_field);
 try {
 // define all the static fields
 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-if (l.head.getTag() == JCTree.VARDEF) {
+if (l.head.hasTag(VARDEF)) {
 JCVariableDecl def = (JCVariableDecl)l.head;
 if ((def.mods.flags & STATIC) != 0) {
 VarSymbol sym = def.sym;
 if (trackable(sym))
 newVar(sym);
 }
 }
 // process all the static initializers
 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-if (l.head.getTag() != JCTree.METHODDEF &&
+if (!l.head.hasTag(METHODDEF) &&
 (TreeInfo.flags(l.head) & STATIC) != 0) {
 scanDef(l.head);
 errorUncaught();
 }
 }
 }
 }
 // define all the instance fields
 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-if (l.head.getTag() == JCTree.VARDEF) {
+if (l.head.hasTag(VARDEF)) {
 JCVariableDecl def = (JCVariableDecl)l.head;
 if ((def.mods.flags & STATIC) == 0) {
 VarSymbol sym = def.sym;
 if (trackable(sym))
 newVar(sym);
 }
 }
 // process all the instance initializers
 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-if (l.head.getTag() != JCTree.METHODDEF &&
+if (!l.head.hasTag(METHODDEF) &&
 (TreeInfo.flags(l.head) & STATIC) == 0) {
 scanDef(l.head);
 errorUncaught();
 }
 }
 thrownPrev = chk.union(thrown, thrownPrev);
 }
 // process all the methods
 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-if (l.head.getTag() == JCTree.METHODDEF) {
+if (l.head.hasTag(METHODDEF)) {
 scan(l.head);
 errorUncaught();
 }
 }
 pendingExits = new ListBuffer<PendingExit>();
 while (exits.nonEmpty()) {
 PendingExit exit = exits.head;
 exits = exits.tail;
 if (exit.thrown == null) {
-Assert.check(exit.tree.getTag() == JCTree.RETURN);
+Assert.check(exit.tree.hasTag(RETURN));
 if (isInitialConstructor) {
 inits = exit.inits;
 for (int i = firstadr; i < nextadr; i++)
 checkInit(exit.tree.pos(), vars[i]);
 }
 /** Add any variables defined in stats to inits and uninits. */
 private static void addVars(List<JCStatement> stats, Bits inits,
 Bits uninits) {
 for (;stats.nonEmpty(); stats = stats.tail) {
 JCTree stat = stats.head;
-if (stat.getTag() == JCTree.VARDEF) {
+if (stat.hasTag(VARDEF)) {
 int adr = ((JCVariableDecl) stat).sym.adr;
 inits.excl(adr);
 uninits.incl(adr);
 }
 }
 letInit(tree.lhs);
 }
 public void visitUnary(JCUnary tree) {
 switch (tree.getTag()) {
-case JCTree.NOT:
+case NOT:
 scanCond(tree.arg);
 Bits t = initsWhenFalse;
 initsWhenFalse = initsWhenTrue;
 initsWhenTrue = t;
 t = uninitsWhenFalse;
 uninitsWhenFalse = uninitsWhenTrue;
 uninitsWhenTrue = t;
 break;
-case JCTree.PREINC: case JCTree.POSTINC:
+case PREINC: case POSTINC:
-case JCTree.PREDEC: case JCTree.POSTDEC:
+case PREDEC: case POSTDEC:
 scanExpr(tree.arg);
 letInit(tree.arg);
 break;
 default:
 scanExpr(tree.arg);
 }
 }
 public void visitBinary(JCBinary tree) {
 switch (tree.getTag()) {
-case JCTree.AND:
+case AND:
 scanCond(tree.lhs);
 Bits initsWhenFalseLeft = initsWhenFalse;
 Bits uninitsWhenFalseLeft = uninitsWhenFalse;
 inits = initsWhenTrue;
 uninits = uninitsWhenTrue;
 scanCond(tree.rhs);
 initsWhenFalse.andSet(initsWhenFalseLeft);
 uninitsWhenFalse.andSet(uninitsWhenFalseLeft);
 break;
-case JCTree.OR:
+case OR:
 scanCond(tree.lhs);
 Bits initsWhenTrueLeft = initsWhenTrue;
 Bits uninitsWhenTrueLeft = uninitsWhenTrue;
 inits = initsWhenFalse;
 uninits = uninitsWhenFalse;
 }
 //where
 private boolean is292targetTypeCast(JCTypeCast tree) {
 boolean is292targetTypeCast = false;
 JCExpression expr = TreeInfo.skipParens(tree.expr);
-if (expr.getTag() == JCTree.APPLY) {
+if (expr.hasTag(APPLY)) {
 JCMethodInvocation apply = (JCMethodInvocation)expr;
 Symbol sym = TreeInfo.symbol(apply.meth);
 is292targetTypeCast = sym != null &&
 sym.kind == MTH &&
 (sym.flags() & POLYMORPHIC_SIGNATURE) != 0;

changeset 10950	e87b50888909
parent 9601	a1b1716231ca
child 12333	7b02d0529a97