jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Flow.java

-:976523f1d562
+:7f6d6b80a58b
 /*
-* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 PendingExit(JCTree tree) {
 this.tree = tree;
 }
-void resolveJump(JCTree tree) {
+void resolveJump() {
 //do nothing
 }
 }
-abstract void markDead(JCTree tree);
+abstract void markDead();
 /** Record an outward transfer of control. */
-void recordExit(JCTree tree, P pe) {
+void recordExit(P pe) {
 pendingExits.append(pe);
-markDead(tree);
+markDead();
 }
 /** Resolve all jumps of this statement. */
 private boolean resolveJump(JCTree tree,
 ListBuffer<P> oldPendingExits,
 pendingExits = oldPendingExits;
 for (; exits.nonEmpty(); exits = exits.tail) {
 P exit = exits.head;
 if (exit.tree.hasTag(jk.treeTag) &&
 jk.getTarget(exit.tree) == tree) {
-exit.resolveJump(tree);
+exit.resolveJump();
 resolved = true;
 } else {
 pendingExits.append(exit);
 }
 }
 *  complete normally.
 */
 private boolean alive;
 @Override
-void markDead(JCTree tree) {
+void markDead() {
 alive = false;
 }
 /*************************************************************************
 * Visitor methods for statements and definitions
 if (tree.sym == null) return;
 boolean alivePrev = alive;
 ListBuffer<PendingExit> pendingExitsPrev = pendingExits;
 Lint lintPrev = lint;
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 lint = lint.augment(tree.sym);
 try {
 // process all the static initializers
 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
 if (alive && !tree.sym.type.getReturnType().hasTag(VOID))
 log.error(TreeInfo.diagEndPos(tree.body), "missing.ret.stmt");
 List<PendingExit> exits = pendingExits.toList();
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 while (exits.nonEmpty()) {
 PendingExit exit = exits.head;
 exits = exits.tail;
 Assert.check(exit.tree.hasTag(RETURN));
 }
 scanStats(tree.stats);
 }
 public void visitDoLoop(JCDoWhileLoop tree) {
 ListBuffer<PendingExit> prevPendingExits = pendingExits;
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 scanStat(tree.body);
 alive |= resolveContinues(tree);
 scan(tree.cond);
 alive = alive && !tree.cond.type.isTrue();
 alive |= resolveBreaks(tree, prevPendingExits);
 }
 public void visitWhileLoop(JCWhileLoop tree) {
 ListBuffer<PendingExit> prevPendingExits = pendingExits;
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 scan(tree.cond);
 alive = !tree.cond.type.isFalse();
 scanStat(tree.body);
 alive |= resolveContinues(tree);
 alive = resolveBreaks(tree, prevPendingExits) ||
 }
 public void visitForLoop(JCForLoop tree) {
 ListBuffer<PendingExit> prevPendingExits = pendingExits;
 scanStats(tree.init);
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 if (tree.cond != null) {
 scan(tree.cond);
 alive = !tree.cond.type.isFalse();
 } else {
 alive = true;
 public void visitForeachLoop(JCEnhancedForLoop tree) {
 visitVarDef(tree.var);
 ListBuffer<PendingExit> prevPendingExits = pendingExits;
 scan(tree.expr);
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 scanStat(tree.body);
 alive |= resolveContinues(tree);
 resolveBreaks(tree, prevPendingExits);
 alive = true;
 }
 public void visitLabelled(JCLabeledStatement tree) {
 ListBuffer<PendingExit> prevPendingExits = pendingExits;
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 scanStat(tree.body);
 alive |= resolveBreaks(tree, prevPendingExits);
 }
 public void visitSwitch(JCSwitch tree) {
 ListBuffer<PendingExit> prevPendingExits = pendingExits;
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 scan(tree.selector);
 boolean hasDefault = false;
 for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
 alive = true;
 JCCase c = l.head;
 alive |= resolveBreaks(tree, prevPendingExits);
 }
 public void visitTry(JCTry tree) {
 ListBuffer<PendingExit> prevPendingExits = pendingExits;
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 for (JCTree resource : tree.resources) {
 if (resource instanceof JCVariableDecl) {
 JCVariableDecl vdecl = (JCVariableDecl) resource;
 visitVarDef(vdecl);
 } else if (resource instanceof JCExpression) {
 alive = true;
 }
 }
 public void visitBreak(JCBreak tree) {
-recordExit(tree, new PendingExit(tree));
+recordExit(new PendingExit(tree));
 }
 public void visitContinue(JCContinue tree) {
-recordExit(tree, new PendingExit(tree));
+recordExit(new PendingExit(tree));
 }
 public void visitReturn(JCReturn tree) {
 scan(tree.expr);
-recordExit(tree, new PendingExit(tree));
+recordExit(new PendingExit(tree));
 }
 public void visitThrow(JCThrow tree) {
 scan(tree.expr);
-markDead(tree);
+markDead();
 }
 public void visitApply(JCMethodInvocation tree) {
 scan(tree.meth);
 scan(tree.args);
 }
 public void analyzeTree(Env<AttrContext> env, JCTree tree, TreeMaker make) {
 try {
 attrEnv = env;
 Flow.this.make = make;
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 alive = true;
 scan(tree);
 } finally {
 pendingExits = null;
 Flow.this.make = null;
 this.thrown = thrown;
 }
 }
 @Override
-void markDead(JCTree tree) {
+void markDead() {
 //do nothing
 }
 /*-------------------- Exceptions ----------------------*/
 return exc.tsym == syms.throwableType.tsym ||
 exc.tsym == syms.exceptionType.tsym;
 }
 public void visitBreak(JCBreak tree) {
-recordExit(tree, new FlowPendingExit(tree, null));
+recordExit(new FlowPendingExit(tree, null));
 }
 public void visitContinue(JCContinue tree) {
-recordExit(tree, new FlowPendingExit(tree, null));
+recordExit(new FlowPendingExit(tree, null));
 }
 public void visitReturn(JCReturn tree) {
 scan(tree.expr);
-recordExit(tree, new FlowPendingExit(tree, null));
+recordExit(new FlowPendingExit(tree, null));
 }
 public void visitThrow(JCThrow tree) {
 scan(tree.expr);
 Symbol sym = TreeInfo.symbol(tree.expr);
 }
 }
 else {
 markThrown(tree, tree.expr.type);
 }
-markDead(tree);
+markDead();
 }
 public void visitApply(JCMethodInvocation tree) {
 scan(tree.meth);
 scan(tree.args);
 * which ensures that no final variable is assigned more than once. This visitor
 * depends on the results of the liveliness analyzer. This pass is also used to mark
 * effectively-final local variables/parameters.
 */
-public abstract class AbstractAssignAnalyzer<P extends AbstractAssignAnalyzer<P>.AbstractAssignPendingExit>
+public class AssignAnalyzer extends BaseAnalyzer<AssignAnalyzer.AssignPendingExit> {
-extends BaseAnalyzer<P> {
 /** The set of definitely assigned variables.
 */
-protected Bits inits;
+final Bits inits;
 /** The set of definitely unassigned variables.
 */
 final Bits uninits;
 /** The list of unreferenced automatic resources.
 */
 Scope unrefdResources;
-/** Set when processing a loop body the second time for DU analysis. */
+/** Modified when processing a loop body the second time for DU analysis. */
 FlowKind flowKind = FlowKind.NORMAL;
-/** The starting position of the analysed tree */
+/** The starting position of the analyzed tree */
 int startPos;
-public class AbstractAssignPendingExit extends BaseAnalyzer.PendingExit {
+public class AssignPendingExit extends BaseAnalyzer.PendingExit {
 final Bits inits;
 final Bits uninits;
 final Bits exit_inits = new Bits(true);
 final Bits exit_uninits = new Bits(true);
-public AbstractAssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
+public AssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
 super(tree);
 this.inits = inits;
 this.uninits = uninits;
 this.exit_inits.assign(inits);
 this.exit_uninits.assign(uninits);
 }
 @Override
-public void resolveJump(JCTree tree) {
+void resolveJump() {
 inits.andSet(exit_inits);
 uninits.andSet(exit_uninits);
 }
 }
-public AbstractAssignAnalyzer() {
+public AssignAnalyzer() {
 this.inits = new Bits();
 uninits = new Bits();
 uninitsTry = new Bits();
 initsWhenTrue = new Bits(true);
 initsWhenFalse = new Bits(true);
 }
 private boolean isInitialConstructor = false;
 @Override
-protected void markDead(JCTree tree) {
+void markDead() {
 if (!isInitialConstructor) {
 inits.inclRange(returnadr, nextadr);
 } else {
 for (int address = returnadr; address < nextadr; address++) {
 if (!(isFinalUninitializedStaticField(vardecls[address].sym))) {
 if ((sym.flags() & FINAL) == 0) {
 sym.flags_field |= EFFECTIVELY_FINAL;
 }
 sym.adr = nextadr;
 vardecls[nextadr] = varDecl;
-exclVarFromInits(varDecl, nextadr);
+inits.excl(nextadr);
 uninits.incl(nextadr);
 nextadr++;
 }
-protected void exclVarFromInits(JCTree tree, int adr) {
-inits.excl(adr);
-}
-protected void assignToInits(JCTree tree, Bits bits) {
-inits.assign(bits);
-}
-protected void andSetInits(JCTree tree, Bits bits) {
-inits.andSet(bits);
-}
-protected void orSetInits(JCTree tree, Bits bits) {
-inits.orSet(bits);
-}
 /** Record an initialization of a trackable variable.
 */
 void letInit(DiagnosticPosition pos, VarSymbol sym) {
 if (sym.adr >= firstadr && trackable(sym)) {
-if (uninits.isMember(sym.adr)) {
+if ((sym.flags() & EFFECTIVELY_FINAL) != 0) {
-uninit(sym);
+if (!uninits.isMember(sym.adr)) {
+//assignment targeting an effectively final variable
+//makes the variable lose its status of effectively final
+//if the variable is _not_ definitively unassigned
+sym.flags_field &= ~EFFECTIVELY_FINAL;
+} else {
+uninit(sym);
+}
+} else if ((sym.flags() & FINAL) != 0) {
+if ((sym.flags() & PARAMETER) != 0) {
+if ((sym.flags() & UNION) != 0) { //multi-catch parameter
+log.error(pos, "multicatch.parameter.may.not.be.assigned", sym);
+} else {
+log.error(pos, "final.parameter.may.not.be.assigned",
+sym);
+}
+} else if (!uninits.isMember(sym.adr)) {
+log.error(pos, flowKind.errKey, sym);
+} else {
+uninit(sym);
+}
 }
 inits.incl(sym.adr);
+} else if ((sym.flags() & FINAL) != 0) {
+log.error(pos, "var.might.already.be.assigned", sym);
 }
 }
 //where
 void uninit(VarSymbol sym) {
 if (!inits.isMember(sym.adr)) {
 */
 void checkInit(DiagnosticPosition pos, VarSymbol sym) {
 checkInit(pos, sym, "var.might.not.have.been.initialized");
 }
-void checkInit(DiagnosticPosition pos, VarSymbol sym, String errkey) {}
+void checkInit(DiagnosticPosition pos, VarSymbol sym, String errkey) {
+if ((sym.adr >= firstadr || sym.owner.kind != TYP) &&
+trackable(sym) &&
+!inits.isMember(sym.adr)) {
+log.error(pos, errkey, sym);
+inits.incl(sym.adr);
+}
+}
 /** Utility method to reset several Bits instances.
 */
 private void resetBits(Bits... bits) {
 for (Bits b : bits) {
 }
 }
 /** Merge (intersect) inits/uninits from WhenTrue/WhenFalse sets.
 */
-protected void merge(JCTree tree) {
+protected void merge() {
 inits.assign(initsWhenFalse.andSet(initsWhenTrue));
 uninits.assign(uninitsWhenFalse.andSet(uninitsWhenTrue));
 }
 /* ************************************************************************
 */
 void scanExpr(JCTree tree) {
 if (tree != null) {
 scan(tree);
 if (inits.isReset()) {
-merge(tree);
+merge();
 }
 }
 }
 /** Analyze a list of expressions.
 /** Analyze a condition. Make sure to set (un)initsWhenTrue(WhenFalse)
 *  rather than (un)inits on exit.
 */
 void scanCond(JCTree tree) {
 if (tree.type.isFalse()) {
-if (inits.isReset()) merge(tree);
+if (inits.isReset()) merge();
 initsWhenTrue.assign(inits);
 initsWhenTrue.inclRange(firstadr, nextadr);
 uninitsWhenTrue.assign(uninits);
 uninitsWhenTrue.inclRange(firstadr, nextadr);
 initsWhenFalse.assign(inits);
 uninitsWhenFalse.assign(uninits);
 } else if (tree.type.isTrue()) {
-if (inits.isReset()) merge(tree);
+if (inits.isReset()) merge();
 initsWhenFalse.assign(inits);
 initsWhenFalse.inclRange(firstadr, nextadr);
 uninitsWhenFalse.assign(uninits);
 uninitsWhenFalse.inclRange(firstadr, nextadr);
 initsWhenTrue.assign(inits);
 }
 }
 /* ------------ Visitor methods for various sorts of trees -------------*/
-@Override
 public void visitClassDef(JCClassDecl tree) {
 if (tree.sym == null) {
 return;
 }
-JCClassDecl classDefPrev = classDef;
+Lint lintPrev = lint;
-int firstadrPrev = firstadr;
+lint = lint.augment(tree.sym);
-int nextadrPrev = nextadr;
-ListBuffer<P> pendingExitsPrev = pendingExits;
-pendingExits = new ListBuffer<P>();
-if (tree.name != names.empty) {
-firstadr = nextadr;
-}
-classDef = tree;
 try {
-// define all the static fields
+if (tree.sym == null) {
-for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+return;
-if (l.head.hasTag(VARDEF)) {
+}
-JCVariableDecl def = (JCVariableDecl)l.head;
-if ((def.mods.flags & STATIC) != 0) {
+JCClassDecl classDefPrev = classDef;
-VarSymbol sym = def.sym;
+int firstadrPrev = firstadr;
-if (trackable(sym)) {
+int nextadrPrev = nextadr;
-newVar(def);
+ListBuffer<AssignPendingExit> pendingExitsPrev = pendingExits;
+pendingExits = new ListBuffer<>();
+if (tree.name != names.empty) {
+firstadr = nextadr;
+}
+classDef = tree;
+try {
+// define all the static fields
+for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+if (l.head.hasTag(VARDEF)) {
+JCVariableDecl def = (JCVariableDecl)l.head;
+if ((def.mods.flags & STATIC) != 0) {
+VarSymbol sym = def.sym;
+if (trackable(sym)) {
+newVar(def);
+}
 }
 }
 }
-}
+// process all the static initializers
-// process all the static initializers
+for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+if (!l.head.hasTag(METHODDEF) &&
-if (!l.head.hasTag(METHODDEF) &&
+(TreeInfo.flags(l.head) & STATIC) != 0) {
-(TreeInfo.flags(l.head) & STATIC) != 0) {
+scan(l.head);
-scan(l.head);
+}
 }
-}
+// define all the instance fields
-// define all the instance fields
+for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+if (l.head.hasTag(VARDEF)) {
-if (l.head.hasTag(VARDEF)) {
+JCVariableDecl def = (JCVariableDecl)l.head;
-JCVariableDecl def = (JCVariableDecl)l.head;
+if ((def.mods.flags & STATIC) == 0) {
-if ((def.mods.flags & STATIC) == 0) {
+VarSymbol sym = def.sym;
-VarSymbol sym = def.sym;
+if (trackable(sym)) {
-if (trackable(sym)) {
+newVar(def);
-newVar(def);
+}
 }
 }
 }
-}
+// process all the instance initializers
+for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-// process all the instance initializers
+if (!l.head.hasTag(METHODDEF) &&
-for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+(TreeInfo.flags(l.head) & STATIC) == 0) {
-if (!l.head.hasTag(METHODDEF) &&
+scan(l.head);
-(TreeInfo.flags(l.head) & STATIC) == 0) {
+}
-scan(l.head);
+}
-}
-}
+// process all the methods
+for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
-// process all the methods
+if (l.head.hasTag(METHODDEF)) {
-for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+scan(l.head);
-if (l.head.hasTag(METHODDEF)) {
+}
-scan(l.head);
+}
-}
+} finally {
+pendingExits = pendingExitsPrev;
+nextadr = nextadrPrev;
+firstadr = firstadrPrev;
+classDef = classDefPrev;
 }
 } finally {
-pendingExits = pendingExitsPrev;
+lint = lintPrev;
-nextadr = nextadrPrev;
+}
-firstadr = firstadrPrev;
+}
-classDef = classDefPrev;
-}
-}
-@Override
 public void visitMethodDef(JCMethodDecl tree) {
 if (tree.body == null) {
 return;
 }
-/*  Ignore synthetic methods, except for translated lambda methods.
+/*  MemberEnter can generate synthetic methods ignore them
 */
-if ((tree.sym.flags() & (SYNTHETIC | LAMBDA_METHOD)) == SYNTHETIC) {
+if ((tree.sym.flags() & SYNTHETIC) != 0) {
 return;
 }
-final Bits initsPrev = new Bits(inits);
+Lint lintPrev = lint;
-final Bits uninitsPrev = new Bits(uninits);
+lint = lint.augment(tree.sym);
-int nextadrPrev = nextadr;
-int firstadrPrev = firstadr;
-int returnadrPrev = returnadr;
-Assert.check(pendingExits.isEmpty());
-boolean lastInitialConstructor = isInitialConstructor;
 try {
-isInitialConstructor = TreeInfo.isInitialConstructor(tree);
+if (tree.body == null) {
+return;
-if (!isInitialConstructor) {
+}
-firstadr = nextadr;
+/*  Ignore synthetic methods, except for translated lambda methods.
-}
+*/
-for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
+if ((tree.sym.flags() & (SYNTHETIC | LAMBDA_METHOD)) == SYNTHETIC) {
-JCVariableDecl def = l.head;
+return;
-scan(def);
+}
-Assert.check((def.sym.flags() & PARAMETER) != 0, "Method parameter without PARAMETER flag");
-/*  If we are executing the code from Gen, then there can be
+final Bits initsPrev = new Bits(inits);
-*  synthetic or mandated variables, ignore them.
+final Bits uninitsPrev = new Bits(uninits);
-*/
+int nextadrPrev = nextadr;
-initParam(def);
+int firstadrPrev = firstadr;
-}
+int returnadrPrev = returnadr;
-// else we are in an instance initializer block;
-// leave caught unchanged.
+Assert.check(pendingExits.isEmpty());
-scan(tree.body);
+boolean lastInitialConstructor = isInitialConstructor;
+try {
-if (isInitialConstructor) {
+isInitialConstructor = TreeInfo.isInitialConstructor(tree);
-boolean isSynthesized = (tree.sym.flags() &
-GENERATEDCONSTR) != 0;
+if (!isInitialConstructor) {
-for (int i = firstadr; i < nextadr; i++) {
+firstadr = nextadr;
-JCVariableDecl vardecl = vardecls[i];
+}
-VarSymbol var = vardecl.sym;
+for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
-if (var.owner == classDef.sym) {
+JCVariableDecl def = l.head;
-// choose the diagnostic position based on whether
+scan(def);
-// the ctor is default(synthesized) or not
+Assert.check((def.sym.flags() & PARAMETER) != 0, "Method parameter without PARAMETER flag");
-if (isSynthesized) {
+/*  If we are executing the code from Gen, then there can be
-checkInit(TreeInfo.diagnosticPositionFor(var, vardecl),
+*  synthetic or mandated variables, ignore them.
-var, "var.not.initialized.in.default.constructor");
+*/
-} else {
+initParam(def);
-checkInit(TreeInfo.diagEndPos(tree.body), var);
+}
+// else we are in an instance initializer block;
+// leave caught unchanged.
+scan(tree.body);
+if (isInitialConstructor) {
+boolean isSynthesized = (tree.sym.flags() &
+GENERATEDCONSTR) != 0;
+for (int i = firstadr; i < nextadr; i++) {
+JCVariableDecl vardecl = vardecls[i];
+VarSymbol var = vardecl.sym;
+if (var.owner == classDef.sym) {
+// choose the diagnostic position based on whether
+// the ctor is default(synthesized) or not
+if (isSynthesized) {
+checkInit(TreeInfo.diagnosticPositionFor(var, vardecl),
+var, "var.not.initialized.in.default.constructor");
+} else {
+checkInit(TreeInfo.diagEndPos(tree.body), var);
+}
 }
 }
 }
-}
+List<AssignPendingExit> exits = pendingExits.toList();
-List<P> exits = pendingExits.toList();
+pendingExits = new ListBuffer<>();
-pendingExits = new ListBuffer<>();
+while (exits.nonEmpty()) {
-while (exits.nonEmpty()) {
+AssignPendingExit exit = exits.head;
-P exit = exits.head;
+exits = exits.tail;
-exits = exits.tail;
+Assert.check(exit.tree.hasTag(RETURN), exit.tree);
-Assert.check(exit.tree.hasTag(RETURN), exit.tree);
+if (isInitialConstructor) {
-if (isInitialConstructor) {
+inits.assign(exit.exit_inits);
-assignToInits(exit.tree, exit.exit_inits);
+for (int i = firstadr; i < nextadr; i++) {
-for (int i = firstadr; i < nextadr; i++) {
+checkInit(exit.tree.pos(), vardecls[i].sym);
-checkInit(exit.tree.pos(), vardecls[i].sym);
+}
 }
 }
+} finally {
+inits.assign(initsPrev);
+uninits.assign(uninitsPrev);
+nextadr = nextadrPrev;
+firstadr = firstadrPrev;
+returnadr = returnadrPrev;
+isInitialConstructor = lastInitialConstructor;
 }
 } finally {
-assignToInits(tree, initsPrev);
+lint = lintPrev;
-uninits.assign(uninitsPrev);
-nextadr = nextadrPrev;
-firstadr = firstadrPrev;
-returnadr = returnadrPrev;
-isInitialConstructor = lastInitialConstructor;
 }
 }
 protected void initParam(JCVariableDecl def) {
 inits.incl(def.sym.adr);
 uninits.excl(def.sym.adr);
 }
 public void visitVarDef(JCVariableDecl tree) {
-boolean track = trackable(tree.sym);
+Lint lintPrev = lint;
-if (track && tree.sym.owner.kind == MTH) {
+lint = lint.augment(tree.sym);
-newVar(tree);
+try{
-}
+boolean track = trackable(tree.sym);
-if (tree.init != null) {
+if (track && tree.sym.owner.kind == MTH) {
-scanExpr(tree.init);
+newVar(tree);
-if (track) {
+}
-letInit(tree.pos(), tree.sym);
+if (tree.init != null) {
-}
+scanExpr(tree.init);
+if (track) {
+letInit(tree.pos(), tree.sym);
+}
+}
+} finally {
+lint = lintPrev;
 }
 }
 public void visitBlock(JCBlock tree) {
 int nextadrPrev = nextadr;
 scan(tree.stats);
 nextadr = nextadrPrev;
 }
-int getLogNumberOfErrors() {
-return 0;
-}
 public void visitDoLoop(JCDoWhileLoop tree) {
-ListBuffer<P> prevPendingExits = pendingExits;
+ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 final Bits initsSkip = new Bits(true);
 final Bits uninitsSkip = new Bits(true);
-pendingExits = new ListBuffer<P>();
+pendingExits = new ListBuffer<>();
-int prevErrors = getLogNumberOfErrors();
+int prevErrors = log.nerrors;
 do {
 final Bits uninitsEntry = new Bits(uninits);
 uninitsEntry.excludeFrom(nextadr);
 scan(tree.body);
 resolveContinues(tree);
 scanCond(tree.cond);
 if (!flowKind.isFinal()) {
 initsSkip.assign(initsWhenFalse);
 uninitsSkip.assign(uninitsWhenFalse);
 }
-if (getLogNumberOfErrors() !=  prevErrors ||
+if (log.nerrors !=  prevErrors ||
 flowKind.isFinal() ||
 new Bits(uninitsEntry).diffSet(uninitsWhenTrue).nextBit(firstadr)==-1)
 break;
-assignToInits(tree.cond, initsWhenTrue);
+inits.assign(initsWhenTrue);
 uninits.assign(uninitsEntry.andSet(uninitsWhenTrue));
 flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
 flowKind = prevFlowKind;
-assignToInits(tree, initsSkip);
+inits.assign(initsSkip);
 uninits.assign(uninitsSkip);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitWhileLoop(JCWhileLoop tree) {
-ListBuffer<P> prevPendingExits = pendingExits;
+ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 final Bits initsSkip = new Bits(true);
 final Bits uninitsSkip = new Bits(true);
 pendingExits = new ListBuffer<>();
-int prevErrors = getLogNumberOfErrors();
+int prevErrors = log.nerrors;
 final Bits uninitsEntry = new Bits(uninits);
 uninitsEntry.excludeFrom(nextadr);
 do {
 scanCond(tree.cond);
 if (!flowKind.isFinal()) {
 initsSkip.assign(initsWhenFalse) ;
 uninitsSkip.assign(uninitsWhenFalse);
 }
-assignToInits(tree, initsWhenTrue);
+inits.assign(initsWhenTrue);
 uninits.assign(uninitsWhenTrue);
 scan(tree.body);
 resolveContinues(tree);
-if (getLogNumberOfErrors() != prevErrors ||
+if (log.nerrors != prevErrors ||
 flowKind.isFinal() ||
 new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1) {
 break;
 }
 uninits.assign(uninitsEntry.andSet(uninits));
 flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
 flowKind = prevFlowKind;
 //a variable is DA/DU after the while statement, if it's DA/DU assuming the
 //branch is not taken AND if it's DA/DU before any break statement
-assignToInits(tree.body, initsSkip);
+inits.assign(initsSkip);
 uninits.assign(uninitsSkip);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitForLoop(JCForLoop tree) {
-ListBuffer<P> prevPendingExits = pendingExits;
+ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 int nextadrPrev = nextadr;
 scan(tree.init);
 final Bits initsSkip = new Bits(true);
 final Bits uninitsSkip = new Bits(true);
-pendingExits = new ListBuffer<P>();
+pendingExits = new ListBuffer<>();
-int prevErrors = getLogNumberOfErrors();
+int prevErrors = log.nerrors;
 do {
 final Bits uninitsEntry = new Bits(uninits);
 uninitsEntry.excludeFrom(nextadr);
 if (tree.cond != null) {
 scanCond(tree.cond);
 if (!flowKind.isFinal()) {
 initsSkip.assign(initsWhenFalse);
 uninitsSkip.assign(uninitsWhenFalse);
 }
-assignToInits(tree.body, initsWhenTrue);
+inits.assign(initsWhenTrue);
 uninits.assign(uninitsWhenTrue);
 } else if (!flowKind.isFinal()) {
 initsSkip.assign(inits);
 initsSkip.inclRange(firstadr, nextadr);
 uninitsSkip.assign(uninits);
 uninitsSkip.inclRange(firstadr, nextadr);
 }
 scan(tree.body);
 resolveContinues(tree);
 scan(tree.step);
-if (getLogNumberOfErrors() != prevErrors ||
+if (log.nerrors != prevErrors ||
 flowKind.isFinal() ||
 new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1)
 break;
 uninits.assign(uninitsEntry.andSet(uninits));
 flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
 flowKind = prevFlowKind;
 //a variable is DA/DU after a for loop, if it's DA/DU assuming the
 //branch is not taken AND if it's DA/DU before any break statement
-assignToInits(tree.body, initsSkip);
+inits.assign(initsSkip);
 uninits.assign(uninitsSkip);
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 public void visitForeachLoop(JCEnhancedForLoop tree) {
 visitVarDef(tree.var);
-ListBuffer<P> prevPendingExits = pendingExits;
+ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 int nextadrPrev = nextadr;
 scan(tree.expr);
 final Bits initsStart = new Bits(inits);
 final Bits uninitsStart = new Bits(uninits);
 letInit(tree.pos(), tree.var.sym);
-pendingExits = new ListBuffer<P>();
+pendingExits = new ListBuffer<>();
-int prevErrors = getLogNumberOfErrors();
+int prevErrors = log.nerrors;
 do {
 final Bits uninitsEntry = new Bits(uninits);
 uninitsEntry.excludeFrom(nextadr);
 scan(tree.body);
 resolveContinues(tree);
-if (getLogNumberOfErrors() != prevErrors ||
+if (log.nerrors != prevErrors ||
 flowKind.isFinal() ||
 new Bits(uninitsEntry).diffSet(uninits).nextBit(firstadr) == -1)
 break;
 uninits.assign(uninitsEntry.andSet(uninits));
 flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
 flowKind = prevFlowKind;
-assignToInits(tree.body, initsStart);
+inits.assign(initsStart);
 uninits.assign(uninitsStart.andSet(uninits));
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 public void visitLabelled(JCLabeledStatement tree) {
-ListBuffer<P> prevPendingExits = pendingExits;
+ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
-pendingExits = new ListBuffer<P>();
+pendingExits = new ListBuffer<>();
 scan(tree.body);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitSwitch(JCSwitch tree) {
-ListBuffer<P> prevPendingExits = pendingExits;
+ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 int nextadrPrev = nextadr;
 scanExpr(tree.selector);
 final Bits initsSwitch = new Bits(inits);
 final Bits uninitsSwitch = new Bits(uninits);
 boolean hasDefault = false;
 for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
-assignToInits(l.head, initsSwitch);
+inits.assign(initsSwitch);
 uninits.assign(uninits.andSet(uninitsSwitch));
 JCCase c = l.head;
 if (c.pat == null) {
 hasDefault = true;
 } else {
 scanExpr(c.pat);
 }
 if (hasDefault) {
-assignToInits(null, initsSwitch);
+inits.assign(initsSwitch);
 uninits.assign(uninits.andSet(uninitsSwitch));
 }
 scan(c.stats);
 addVars(c.stats, initsSwitch, uninitsSwitch);
 if (!hasDefault) {
-assignToInits(l.head.stats.last(), initsSwitch);
+inits.assign(initsSwitch);
 uninits.assign(uninits.andSet(uninitsSwitch));
 }
 // Warn about fall-through if lint switch fallthrough enabled.
 }
 if (!hasDefault) {
-andSetInits(null, initsSwitch);
+inits.andSet(initsSwitch);
 }
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 // where
 uninits.incl(adr);
 }
 }
 }
-boolean isEnabled(Lint.LintCategory lc) {
-return false;
-}
-void reportWarning(Lint.LintCategory lc, DiagnosticPosition pos, String key, Object ... args) {}
 public void visitTry(JCTry tree) {
 ListBuffer<JCVariableDecl> resourceVarDecls = new ListBuffer<>();
 final Bits uninitsTryPrev = new Bits(uninitsTry);
-ListBuffer<P> prevPendingExits = pendingExits;
+ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 final Bits initsTry = new Bits(inits);
 uninitsTry.assign(uninits);
 for (JCTree resource : tree.resources) {
 if (resource instanceof JCVariableDecl) {
 final Bits initsEnd = new Bits(inits);
 final Bits uninitsEnd = new Bits(uninits);
 int nextadrCatch = nextadr;
 if (!resourceVarDecls.isEmpty() &&
-isEnabled(Lint.LintCategory.TRY)) {
+lint.isEnabled(Lint.LintCategory.TRY)) {
 for (JCVariableDecl resVar : resourceVarDecls) {
 if (unrefdResources.includes(resVar.sym)) {
-reportWarning(Lint.LintCategory.TRY, resVar.pos(),
+log.warning(Lint.LintCategory.TRY, resVar.pos(),
 "try.resource.not.referenced", resVar.sym);
 unrefdResources.remove(resVar.sym);
 }
 }
 }
 final Bits initsCatchPrev = new Bits(initsTry);
 final Bits uninitsCatchPrev = new Bits(uninitsTry);
 for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
 JCVariableDecl param = l.head.param;
-assignToInits(tree.body, initsCatchPrev);
+inits.assign(initsCatchPrev);
 uninits.assign(uninitsCatchPrev);
 scan(param);
 /* If this is a TWR and we are executing the code from Gen,
 * then there can be synthetic variables, ignore them.
 */
 initsEnd.andSet(inits);
 uninitsEnd.andSet(uninits);
 nextadr = nextadrCatch;
 }
 if (tree.finalizer != null) {
-assignToInits(tree.finalizer, initsTry);
+inits.assign(initsTry);
 uninits.assign(uninitsTry);
-ListBuffer<P> exits = pendingExits;
+ListBuffer<AssignPendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
 scan(tree.finalizer);
 if (!tree.finallyCanCompleteNormally) {
 // discard exits and exceptions from try and finally
 } else {
 uninits.andSet(uninitsEnd);
 // FIX: this doesn't preserve source order of exits in catch
 // versus finally!
 while (exits.nonEmpty()) {
-P exit = exits.next();
+AssignPendingExit exit = exits.next();
 if (exit.exit_inits != null) {
 exit.exit_inits.orSet(inits);
 exit.exit_uninits.andSet(uninits);
 }
 pendingExits.append(exit);
 }
-orSetInits(tree, initsEnd);
+inits.orSet(initsEnd);
 }
 } else {
-assignToInits(tree, initsEnd);
+inits.assign(initsEnd);
 uninits.assign(uninitsEnd);
-ListBuffer<P> exits = pendingExits;
+ListBuffer<AssignPendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
 while (exits.nonEmpty()) pendingExits.append(exits.next());
 }
 uninitsTry.andSet(uninitsTryPrev).andSet(uninits);
 }
 public void visitConditional(JCConditional tree) {
 scanCond(tree.cond);
 final Bits initsBeforeElse = new Bits(initsWhenFalse);
 final Bits uninitsBeforeElse = new Bits(uninitsWhenFalse);
-assignToInits(tree.cond, initsWhenTrue);
+inits.assign(initsWhenTrue);
 uninits.assign(uninitsWhenTrue);
 if (tree.truepart.type.hasTag(BOOLEAN) &&
 tree.falsepart.type.hasTag(BOOLEAN)) {
 // if b and c are boolean valued, then
 // v is (un)assigned after a?b:c when true iff
 scanCond(tree.truepart);
 final Bits initsAfterThenWhenTrue = new Bits(initsWhenTrue);
 final Bits initsAfterThenWhenFalse = new Bits(initsWhenFalse);
 final Bits uninitsAfterThenWhenTrue = new Bits(uninitsWhenTrue);
 final Bits uninitsAfterThenWhenFalse = new Bits(uninitsWhenFalse);
-assignToInits(tree.truepart, initsBeforeElse);
+inits.assign(initsBeforeElse);
 uninits.assign(uninitsBeforeElse);
 scanCond(tree.falsepart);
 initsWhenTrue.andSet(initsAfterThenWhenTrue);
 initsWhenFalse.andSet(initsAfterThenWhenFalse);
 uninitsWhenTrue.andSet(uninitsAfterThenWhenTrue);
 uninitsWhenFalse.andSet(uninitsAfterThenWhenFalse);
 } else {
 scanExpr(tree.truepart);
 final Bits initsAfterThen = new Bits(inits);
 final Bits uninitsAfterThen = new Bits(uninits);
-assignToInits(tree.truepart, initsBeforeElse);
+inits.assign(initsBeforeElse);
 uninits.assign(uninitsBeforeElse);
 scanExpr(tree.falsepart);
-andSetInits(tree.falsepart, initsAfterThen);
+inits.andSet(initsAfterThen);
 uninits.andSet(uninitsAfterThen);
 }
 }
 public void visitIf(JCIf tree) {
 scanCond(tree.cond);
 final Bits initsBeforeElse = new Bits(initsWhenFalse);
 final Bits uninitsBeforeElse = new Bits(uninitsWhenFalse);
-assignToInits(tree.cond, initsWhenTrue);
+inits.assign(initsWhenTrue);
 uninits.assign(uninitsWhenTrue);
 scan(tree.thenpart);
 if (tree.elsepart != null) {
 final Bits initsAfterThen = new Bits(inits);
 final Bits uninitsAfterThen = new Bits(uninits);
-assignToInits(tree.thenpart, initsBeforeElse);
+inits.assign(initsBeforeElse);
 uninits.assign(uninitsBeforeElse);
 scan(tree.elsepart);
-andSetInits(tree.elsepart, initsAfterThen);
+inits.andSet(initsAfterThen);
 uninits.andSet(uninitsAfterThen);
 } else {
-andSetInits(tree.thenpart, initsBeforeElse);
+inits.andSet(initsBeforeElse);
 uninits.andSet(uninitsBeforeElse);
 }
-}
-protected P createNewPendingExit(JCTree tree, Bits inits, Bits uninits) {
-return null;
 }
 @Override
 public void visitBreak(JCBreak tree) {
-recordExit(tree, createNewPendingExit(tree, inits, uninits));
+recordExit(new AssignPendingExit(tree, inits, uninits));
 }
 @Override
 public void visitContinue(JCContinue tree) {
-recordExit(tree, createNewPendingExit(tree, inits, uninits));
+recordExit(new AssignPendingExit(tree, inits, uninits));
 }
 @Override
 public void visitReturn(JCReturn tree) {
 scanExpr(tree.expr);
-recordExit(tree, createNewPendingExit(tree, inits, uninits));
+recordExit(new AssignPendingExit(tree, inits, uninits));
 }
 public void visitThrow(JCThrow tree) {
 scanExpr(tree.expr);
-markDead(tree.expr);
+markDead();
 }
 public void visitApply(JCMethodInvocation tree) {
 scanExpr(tree.meth);
 scanExprs(tree.args);
 @Override
 public void visitLambda(JCLambda tree) {
 final Bits prevUninits = new Bits(uninits);
 final Bits prevInits = new Bits(inits);
 int returnadrPrev = returnadr;
-ListBuffer<P> prevPending = pendingExits;
+ListBuffer<AssignPendingExit> prevPending = pendingExits;
 try {
 returnadr = nextadr;
-pendingExits = new ListBuffer<P>();
+pendingExits = new ListBuffer<>();
 for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
 JCVariableDecl def = l.head;
 scan(def);
 inits.incl(def.sym.adr);
 uninits.excl(def.sym.adr);
 }
 }
 finally {
 returnadr = returnadrPrev;
 uninits.assign(prevUninits);
-assignToInits(tree, prevInits);
+inits.assign(prevInits);
 pendingExits = prevPending;
 }
 }
 public void visitNewArray(JCNewArray tree) {
 final Bits initsExit = new Bits(inits);
 final Bits uninitsExit = new Bits(uninits);
 scanCond(tree.cond);
 uninitsExit.andSet(uninitsWhenTrue);
 if (tree.detail != null) {
-assignToInits(tree, initsWhenFalse);
+inits.assign(initsWhenFalse);
 uninits.assign(uninitsWhenFalse);
 scanExpr(tree.detail);
 }
-assignToInits(tree, initsExit);
+inits.assign(initsExit);
 uninits.assign(uninitsExit);
 }
 public void visitAssign(JCAssign tree) {
 JCTree lhs = TreeInfo.skipParens(tree.lhs);
 switch (tree.getTag()) {
 case AND:
 scanCond(tree.lhs);
 final Bits initsWhenFalseLeft = new Bits(initsWhenFalse);
 final Bits uninitsWhenFalseLeft = new Bits(uninitsWhenFalse);
-assignToInits(tree.lhs, initsWhenTrue);
+inits.assign(initsWhenTrue);
 uninits.assign(uninitsWhenTrue);
 scanCond(tree.rhs);
 initsWhenFalse.andSet(initsWhenFalseLeft);
 uninitsWhenFalse.andSet(uninitsWhenFalseLeft);
 break;
 case OR:
 scanCond(tree.lhs);
 final Bits initsWhenTrueLeft = new Bits(initsWhenTrue);
 final Bits uninitsWhenTrueLeft = new Bits(uninitsWhenTrue);
-assignToInits(tree.lhs, initsWhenFalse);
+inits.assign(initsWhenFalse);
 uninits.assign(uninitsWhenFalse);
 scanCond(tree.rhs);
 initsWhenTrue.andSet(initsWhenTrueLeft);
 uninitsWhenTrue.andSet(uninitsWhenTrueLeft);
 break;
 unrefdResources = null;
 }
 }
 }
-public class AssignAnalyzer extends AbstractAssignAnalyzer<AssignAnalyzer.AssignPendingExit> {
-public class AssignPendingExit extends AbstractAssignAnalyzer<AssignPendingExit>.AbstractAssignPendingExit {
-public AssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
-super(tree, inits, uninits);
-}
-}
-@Override
-protected AssignPendingExit createNewPendingExit(JCTree tree,
-Bits inits, Bits uninits) {
-return new AssignPendingExit(tree, inits, uninits);
-}
-/** Record an initialization of a trackable variable.
-*/
-@Override
-void letInit(DiagnosticPosition pos, VarSymbol sym) {
-if (sym.adr >= firstadr && trackable(sym)) {
-if ((sym.flags() & EFFECTIVELY_FINAL) != 0) {
-if (!uninits.isMember(sym.adr)) {
-//assignment targeting an effectively final variable
-//makes the variable lose its status of effectively final
-//if the variable is _not_ definitively unassigned
-sym.flags_field &= ~EFFECTIVELY_FINAL;
-} else {
-uninit(sym);
-}
-}
-else if ((sym.flags() & FINAL) != 0) {
-if ((sym.flags() & PARAMETER) != 0) {
-if ((sym.flags() & UNION) != 0) { //multi-catch parameter
-log.error(pos, "multicatch.parameter.may.not.be.assigned", sym);
-}
-else {
-log.error(pos, "final.parameter.may.not.be.assigned",
-sym);
-}
-} else if (!uninits.isMember(sym.adr)) {
-log.error(pos, flowKind.errKey, sym);
-} else {
-uninit(sym);
-}
-}
-inits.incl(sym.adr);
-} else if ((sym.flags() & FINAL) != 0) {
-log.error(pos, "var.might.already.be.assigned", sym);
-}
-}
-@Override
-void checkInit(DiagnosticPosition pos, VarSymbol sym, String errkey) {
-if ((sym.adr >= firstadr || sym.owner.kind != TYP) &&
-trackable(sym) &&
-!inits.isMember(sym.adr)) {
-log.error(pos, errkey, sym);
-inits.incl(sym.adr);
-}
-}
-@Override
-void reportWarning(Lint.LintCategory lc, DiagnosticPosition pos,
-String key, Object ... args) {
-log.warning(lc, pos, key, args);
-}
-@Override
-int getLogNumberOfErrors() {
-return log.nerrors;
-}
-@Override
-boolean isEnabled(Lint.LintCategory lc) {
-return lint.isEnabled(lc);
-}
-@Override
-public void visitClassDef(JCClassDecl tree) {
-if (tree.sym == null) {
-return;
-}
-Lint lintPrev = lint;
-lint = lint.augment(tree.sym);
-try {
-super.visitClassDef(tree);
-} finally {
-lint = lintPrev;
-}
-}
-@Override
-public void visitMethodDef(JCMethodDecl tree) {
-if (tree.body == null) {
-return;
-}
-/*  MemberEnter can generate synthetic methods ignore them
-*/
-if ((tree.sym.flags() & SYNTHETIC) != 0) {
-return;
-}
-Lint lintPrev = lint;
-lint = lint.augment(tree.sym);
-try {
-super.visitMethodDef(tree);
-} finally {
-lint = lintPrev;
-}
-}
-@Override
-public void visitVarDef(JCVariableDecl tree) {
-if (tree.init == null) {
-super.visitVarDef(tree);
-} else {
-Lint lintPrev = lint;
-lint = lint.augment(tree.sym);
-try{
-super.visitVarDef(tree);
-} finally {
-lint = lintPrev;
-}
-}
-}
-}
 /**
 * This pass implements the last step of the dataflow analysis, namely
 * the effectively-final analysis check. This checks that every local variable
 * reference from a lambda body/local inner class is either final or effectively final.
 * As effectively final variables are marked as such during DA/DU, this pass must run after
 class CaptureAnalyzer extends BaseAnalyzer<BaseAnalyzer.PendingExit> {
 JCTree currentTree; //local class or lambda
 @Override
-void markDead(JCTree tree) {
+void markDead() {
 //do nothing
 }
 @SuppressWarnings("fallthrough")
 void checkEffectivelyFinal(DiagnosticPosition pos, VarSymbol sym) {
 }
 public void analyzeTree(Env<AttrContext> env, JCTree tree, TreeMaker make) {
 try {
 attrEnv = env;
 Flow.this.make = make;
-pendingExits = new ListBuffer<PendingExit>();
+pendingExits = new ListBuffer<>();
 scan(tree);
 } finally {
 pendingExits = null;
 Flow.this.make = null;
 }

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

comparison: src/share/classes/com/sun/tools/javac/comp/Flow.java

src/share/classes/com/sun/tools/javac/comp/Flow.java