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

equal deleted inserted replaced

-:83729994273a
+:3025d6ac1401
 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.
+/** This pass implements dataflow analysis for Java programs though
-*  Liveness analysis checks that every statement is reachable.
+*  different AST visitor steps. Liveness analysis (see AliveAlanyzer) checks that
-*  Exception analysis ensures that every checked exception that is
+*  every statement is reachable. Exception analysis (see FlowAnalyzer) ensures that
-*  thrown is declared or caught.  Definite assignment analysis
+*  every checked exception that is thrown is declared or caught.  Definite assignment analysis
-*  ensures that each variable is assigned when used.  Definite
+*  (see AssignAnalyzer) ensures that each variable is assigned when used.  Definite
-*  unassignment analysis ensures that no final variable is assigned
+*  unassignment analysis (see AssignAnalyzer) in ensures that no final variable
-*  more than once.
+*  is assigned more than once. Finally, local variable capture analysis (see CaptureAnalyzer)
+*  determines that local variables accessed within the scope of an inner class are
+*  either final or effectively-final.
 *
 *  <p>The JLS has a number of problems in the
 *  specification of these flow analysis problems. This implementation
 *  attempts to address those issues.
 *
 private final Symtab syms;
 private final Types types;
 private final Check chk;
 private       TreeMaker make;
 private final Resolve rs;
+private final JCDiagnostic.Factory diags;
 private Env<AttrContext> attrEnv;
 private       Lint lint;
 private final boolean allowImprovedRethrowAnalysis;
 private final boolean allowImprovedCatchAnalysis;
+private final boolean allowEffectivelyFinalInInnerClasses;
 public static Flow instance(Context context) {
 Flow instance = context.get(flowKey);
 if (instance == null)
 instance = new Flow(context);
 return instance;
 }
 public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
+new AliveAnalyzer().analyzeTree(env, make);
+new AssignAnalyzer().analyzeTree(env, make);
 new FlowAnalyzer().analyzeTree(env, make);
-new AssignAnalyzer().analyzeTree(env, make);
+new CaptureAnalyzer().analyzeTree(env, make);
+}
+/**
+* Definite assignment scan mode
+*/
+enum FlowKind {
+/**
+* This is the normal DA/DU analysis mode
+*/
+NORMAL("var.might.already.be.assigned", false),
+/**
+* This is the speculative DA/DU analysis mode used to speculatively
+* derive assertions within loop bodies
+*/
+SPECULATIVE_LOOP("var.might.be.assigned.in.loop", true);
+String errKey;
+boolean isFinal;
+FlowKind(String errKey, boolean isFinal) {
+this.errKey = errKey;
+this.isFinal = isFinal;
+}
+boolean isFinal() {
+return isFinal;
+}
 }
 protected Flow(Context context) {
 context.put(flowKey, this);
 names = Names.instance(context);
 syms = Symtab.instance(context);
 types = Types.instance(context);
 chk = Check.instance(context);
 lint = Lint.instance(context);
 rs = Resolve.instance(context);
+diags = JCDiagnostic.Factory.instance(context);
 Source source = Source.instance(context);
 allowImprovedRethrowAnalysis = source.allowImprovedRethrowAnalysis();
 allowImprovedCatchAnalysis = source.allowImprovedCatchAnalysis();
+Options options = Options.instance(context);
+allowEffectivelyFinalInInnerClasses = source.allowEffectivelyFinalInInnerClasses() &&
+options.isSet("allowEffectivelyFinalInInnerClasses"); //pre-lambda guard
 }
 /**
 * Base visitor class for all visitors implementing dataflow analysis logic.
 * This class define the shared logic for handling jumps (break/continue statements).
 *  continue.  In addition, exception-throwing expressions or
 *  statements are put here when not known to be caught.  This
 *  will typically result in an error unless it is within a
 *  try-finally whose finally block cannot complete normally.
 */
-abstract static class PendingExit {
+static class PendingExit {
 JCTree tree;
 PendingExit(JCTree tree) {
 this.tree = tree;
 }
-abstract void resolveJump();
+void resolveJump() {
+//do nothing
+}
 }
 abstract void markDead();
 /** Record an outward transfer of control. */
 return resolveJump(tree, oldPendingExits, JumpKind.BREAK);
 }
 }
 /**
-* This pass implements the first two steps of the dataflow analysis:
+* This pass implements the first step of the dataflow analysis, namely
-* (i) liveness analysis checks that every statement is reachable and (ii)
+* the liveness analysis check. This checks that every statement is reachable.
-*  exception analysis to ensure that every checked exception that is
+* The output of this analysis pass are used by other analyzers. This analyzer
-*  thrown is declared or caught.
+* sets the 'finallyCanCompleteNormally' field in the JCTry class.
+*/
+class AliveAnalyzer extends BaseAnalyzer<BaseAnalyzer.PendingExit> {
+/** A flag that indicates whether the last statement could
+*  complete normally.
+*/
+private boolean alive;
+@Override
+void markDead() {
+alive = false;
+}
+/*************************************************************************
+* Visitor methods for statements and definitions
+*************************************************************************/
+/** Analyze a definition.
+*/
+void scanDef(JCTree tree) {
+scanStat(tree);
+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.hasTag(SKIP)) alive = true;
+}
+scan(tree);
+}
+/** Analyze list of statements.
+*/
+void scanStats(List<? extends JCStatement> trees) {
+if (trees != null)
+for (List<? extends JCStatement> l = trees; l.nonEmpty(); l = l.tail)
+scanStat(l.head);
+}
+/* ------------ Visitor methods for various sorts of trees -------------*/
+public void visitClassDef(JCClassDecl tree) {
+if (tree.sym == null) return;
+boolean alivePrev = alive;
+ListBuffer<PendingExit> pendingExitsPrev = pendingExits;
+Lint lintPrev = lint;
+pendingExits = new ListBuffer<PendingExit>();
+lint = lint.augment(tree.sym.attributes_field);
+try {
+// process all the static initializers
+for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+if (!l.head.hasTag(METHODDEF) &&
+(TreeInfo.flags(l.head) & STATIC) != 0) {
+scanDef(l.head);
+}
+}
+// process all the instance initializers
+for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+if (!l.head.hasTag(METHODDEF) &&
+(TreeInfo.flags(l.head) & STATIC) == 0) {
+scanDef(l.head);
+}
+}
+// process all the methods
+for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
+if (l.head.hasTag(METHODDEF)) {
+scan(l.head);
+}
+}
+} finally {
+pendingExits = pendingExitsPrev;
+alive = alivePrev;
+lint = lintPrev;
+}
+}
+public void visitMethodDef(JCMethodDecl tree) {
+if (tree.body == null) return;
+Lint lintPrev = lint;
+lint = lint.augment(tree.sym.attributes_field);
+Assert.check(pendingExits.isEmpty());
+try {
+alive = true;
+scanStat(tree.body);
+if (alive && tree.sym.type.getReturnType().tag != VOID)
+log.error(TreeInfo.diagEndPos(tree.body), "missing.ret.stmt");
+List<PendingExit> exits = pendingExits.toList();
+pendingExits = new ListBuffer<PendingExit>();
+while (exits.nonEmpty()) {
+PendingExit exit = exits.head;
+exits = exits.tail;
+Assert.check(exit.tree.hasTag(RETURN));
+}
+} finally {
+lint = lintPrev;
+}
+}
+public void visitVarDef(JCVariableDecl tree) {
+if (tree.init != null) {
+Lint lintPrev = lint;
+lint = lint.augment(tree.sym.attributes_field);
+try{
+scan(tree.init);
+} finally {
+lint = lintPrev;
+}
+}
+}
+public void visitBlock(JCBlock tree) {
+scanStats(tree.stats);
+}
+public void visitDoLoop(JCDoWhileLoop tree) {
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
+pendingExits = new ListBuffer<PendingExit>();
+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>();
+scan(tree.cond);
+alive = !tree.cond.type.isFalse();
+scanStat(tree.body);
+alive |= resolveContinues(tree);
+alive = resolveBreaks(tree, prevPendingExits) ||
+!tree.cond.type.isTrue();
+}
+public void visitForLoop(JCForLoop tree) {
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
+scanStats(tree.init);
+pendingExits = new ListBuffer<PendingExit>();
+if (tree.cond != null) {
+scan(tree.cond);
+alive = !tree.cond.type.isFalse();
+} else {
+alive = true;
+}
+scanStat(tree.body);
+alive |= resolveContinues(tree);
+scan(tree.step);
+alive = resolveBreaks(tree, prevPendingExits) ||
+tree.cond != null && !tree.cond.type.isTrue();
+}
+public void visitForeachLoop(JCEnhancedForLoop tree) {
+visitVarDef(tree.var);
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
+scan(tree.expr);
+pendingExits = new ListBuffer<PendingExit>();
+scanStat(tree.body);
+alive |= resolveContinues(tree);
+resolveBreaks(tree, prevPendingExits);
+alive = true;
+}
+public void visitLabelled(JCLabeledStatement tree) {
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
+pendingExits = new ListBuffer<PendingExit>();
+scanStat(tree.body);
+alive |= resolveBreaks(tree, prevPendingExits);
+}
+public void visitSwitch(JCSwitch tree) {
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
+pendingExits = new ListBuffer<PendingExit>();
+scan(tree.selector);
+boolean hasDefault = false;
+for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
+alive = true;
+JCCase c = l.head;
+if (c.pat == null)
+hasDefault = true;
+else
+scan(c.pat);
+scanStats(c.stats);
+// Warn about fall-through if lint switch fallthrough enabled.
+if (alive &&
+lint.isEnabled(Lint.LintCategory.FALLTHROUGH) &&
+c.stats.nonEmpty() && l.tail.nonEmpty())
+log.warning(Lint.LintCategory.FALLTHROUGH,
+l.tail.head.pos(),
+"possible.fall-through.into.case");
+}
+if (!hasDefault) {
+alive = true;
+}
+alive |= resolveBreaks(tree, prevPendingExits);
+}
+public void visitTry(JCTry tree) {
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
+pendingExits = new ListBuffer<PendingExit>();
+for (JCTree resource : tree.resources) {
+if (resource instanceof JCVariableDecl) {
+JCVariableDecl vdecl = (JCVariableDecl) resource;
+visitVarDef(vdecl);
+} else if (resource instanceof JCExpression) {
+scan((JCExpression) resource);
+} else {
+throw new AssertionError(tree);  // parser error
+}
+}
+scanStat(tree.body);
+boolean aliveEnd = alive;
+for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
+alive = true;
+JCVariableDecl param = l.head.param;
+scan(param);
+scanStat(l.head.body);
+aliveEnd |= alive;
+}
+if (tree.finalizer != null) {
+ListBuffer<PendingExit> exits = pendingExits;
+pendingExits = prevPendingExits;
+alive = true;
+scanStat(tree.finalizer);
+tree.finallyCanCompleteNormally = alive;
+if (!alive) {
+if (lint.isEnabled(Lint.LintCategory.FINALLY)) {
+log.warning(Lint.LintCategory.FINALLY,
+TreeInfo.diagEndPos(tree.finalizer),
+"finally.cannot.complete");
+}
+} else {
+while (exits.nonEmpty()) {
+pendingExits.append(exits.next());
+}
+alive = aliveEnd;
+}
+} else {
+alive = aliveEnd;
+ListBuffer<PendingExit> exits = pendingExits;
+pendingExits = prevPendingExits;
+while (exits.nonEmpty()) pendingExits.append(exits.next());
+}
+}
+@Override
+public void visitIf(JCIf tree) {
+scan(tree.cond);
+scanStat(tree.thenpart);
+if (tree.elsepart != null) {
+boolean aliveAfterThen = alive;
+alive = true;
+scanStat(tree.elsepart);
+alive = alive | aliveAfterThen;
+} else {
+alive = true;
+}
+}
+public void visitBreak(JCBreak tree) {
+recordExit(tree, new PendingExit(tree));
+}
+public void visitContinue(JCContinue tree) {
+recordExit(tree, new PendingExit(tree));
+}
+public void visitReturn(JCReturn tree) {
+scan(tree.expr);
+recordExit(tree, new PendingExit(tree));
+}
+public void visitThrow(JCThrow tree) {
+scan(tree.expr);
+markDead();
+}
+public void visitApply(JCMethodInvocation tree) {
+scan(tree.meth);
+scan(tree.args);
+}
+public void visitNewClass(JCNewClass tree) {
+scan(tree.encl);
+scan(tree.args);
+if (tree.def != null) {
+scan(tree.def);
+}
+}
+public void visitTopLevel(JCCompilationUnit tree) {
+// Do nothing for TopLevel since each class is visited individually
+}
+/**************************************************************************
+* main method
+*************************************************************************/
+/** Perform definite assignment/unassignment analysis on a tree.
+*/
+public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
+try {
+attrEnv = env;
+Flow.this.make = make;
+pendingExits = new ListBuffer<PendingExit>();
+alive = true;
+scan(env.tree);
+} finally {
+pendingExits = null;
+Flow.this.make = null;
+}
+}
+}
+/**
+* This pass implements the second step of the dataflow analysis, namely
+* the exception analysis. This is to ensure that every checked exception that is
+* thrown is declared or caught. The analyzer uses some info that has been set by
+* the liveliness analyzer.
 */
 class FlowAnalyzer extends BaseAnalyzer<FlowAnalyzer.FlowPendingExit> {
 /** A flag that indicates whether the last statement could
 *  complete normally.
 */
-private boolean alive;
 HashMap<Symbol, List<Type>> preciseRethrowTypes;
 /** The current class being defined.
 */
 JCClassDecl classDef;
 FlowPendingExit(JCTree tree, Type thrown) {
 super(tree);
 this.thrown = thrown;
 }
-void resolveJump() { /*do nothing*/ }
 }
 @Override
 void markDead() {
-alive = false;
+//do nothing
 }
 /*-------------------- Exceptions ----------------------*/
 /** Complain that pending exceptions are not caught.
 /*************************************************************************
 * Visitor methods for statements and definitions
 *************************************************************************/
-/** Analyze a definition.
-*/
-void scanDef(JCTree tree) {
-scanStat(tree);
-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.hasTag(SKIP)) alive = true;
-}
-scan(tree);
-}
-/** Analyze list of statements.
-*/
-void scanStats(List<? extends JCStatement> trees) {
-if (trees != null)
-for (List<? extends JCStatement> l = trees; l.nonEmpty(); l = l.tail)
-scanStat(l.head);
-}
 /* ------------ Visitor methods for various sorts of trees -------------*/
 public void visitClassDef(JCClassDecl tree) {
 if (tree.sym == null) return;
 JCClassDecl classDefPrev = classDef;
 List<Type> thrownPrev = thrown;
 List<Type> caughtPrev = caught;
-boolean alivePrev = alive;
 ListBuffer<FlowPendingExit> pendingExitsPrev = pendingExits;
 Lint lintPrev = lint;
 pendingExits = new ListBuffer<FlowPendingExit>();
 if (tree.name != names.empty) {
 try {
 // process all the static initializers
 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
 if (!l.head.hasTag(METHODDEF) &&
 (TreeInfo.flags(l.head) & STATIC) != 0) {
-scanDef(l.head);
+scan(l.head);
 errorUncaught();
 }
 }
 // add intersection of all thrown clauses of initial constructors
 // process all the instance initializers
 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
 if (!l.head.hasTag(METHODDEF) &&
 (TreeInfo.flags(l.head) & STATIC) == 0) {
-scanDef(l.head);
+scan(l.head);
 errorUncaught();
 }
 }
 // in an anonymous class, add the set of thrown exceptions to
 }
 thrown = thrownPrev;
 } finally {
 pendingExits = pendingExitsPrev;
-alive = alivePrev;
 caught = caughtPrev;
 classDef = classDefPrev;
 lint = lintPrev;
 }
 }
 else if ((tree.sym.flags() & (BLOCK | STATIC)) != BLOCK)
 caught = mthrown;
 // else we are in an instance initializer block;
 // leave caught unchanged.
-alive = true;
+scan(tree.body);
-scanStat(tree.body);
-if (alive && tree.sym.type.getReturnType().tag != VOID)
-log.error(TreeInfo.diagEndPos(tree.body), "missing.ret.stmt");
 List<FlowPendingExit> exits = pendingExits.toList();
 pendingExits = new ListBuffer<FlowPendingExit>();
 while (exits.nonEmpty()) {
 FlowPendingExit exit = exits.head;
 }
 }
 }
 public void visitBlock(JCBlock tree) {
-scanStats(tree.stats);
+scan(tree.stats);
 }
 public void visitDoLoop(JCDoWhileLoop tree) {
 ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<FlowPendingExit>();
-scanStat(tree.body);
+scan(tree.body);
-alive |= resolveContinues(tree);
+resolveContinues(tree);
 scan(tree.cond);
-alive = alive && !tree.cond.type.isTrue();
+resolveBreaks(tree, prevPendingExits);
-alive |= resolveBreaks(tree, prevPendingExits);
 }
 public void visitWhileLoop(JCWhileLoop tree) {
 ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<FlowPendingExit>();
 scan(tree.cond);
-alive = !tree.cond.type.isFalse();
+scan(tree.body);
-scanStat(tree.body);
+resolveContinues(tree);
-alive |= resolveContinues(tree);
+resolveBreaks(tree, prevPendingExits);
-alive = resolveBreaks(tree, prevPendingExits) ||
-!tree.cond.type.isTrue();
 }
 public void visitForLoop(JCForLoop tree) {
 ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
-scanStats(tree.init);
+scan(tree.init);
 pendingExits = new ListBuffer<FlowPendingExit>();
 if (tree.cond != null) {
 scan(tree.cond);
-alive = !tree.cond.type.isFalse();
+}
-} else {
+scan(tree.body);
-alive = true;
+resolveContinues(tree);
-}
-scanStat(tree.body);
-alive |= resolveContinues(tree);
 scan(tree.step);
-alive = resolveBreaks(tree, prevPendingExits) ||
+resolveBreaks(tree, prevPendingExits);
-tree.cond != null && !tree.cond.type.isTrue();
 }
 public void visitForeachLoop(JCEnhancedForLoop tree) {
 visitVarDef(tree.var);
 ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
 scan(tree.expr);
 pendingExits = new ListBuffer<FlowPendingExit>();
-scanStat(tree.body);
+scan(tree.body);
-alive |= resolveContinues(tree);
+resolveContinues(tree);
 resolveBreaks(tree, prevPendingExits);
-alive = true;
 }
 public void visitLabelled(JCLabeledStatement tree) {
 ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<FlowPendingExit>();
-scanStat(tree.body);
+scan(tree.body);
-alive |= resolveBreaks(tree, prevPendingExits);
+resolveBreaks(tree, prevPendingExits);
 }
 public void visitSwitch(JCSwitch tree) {
 ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<FlowPendingExit>();
 scan(tree.selector);
-boolean hasDefault = false;
 for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
-alive = true;
 JCCase c = l.head;
-if (c.pat == null)
+if (c.pat != null) {
-hasDefault = true;
-else
 scan(c.pat);
-scanStats(c.stats);
+}
-// Warn about fall-through if lint switch fallthrough enabled.
+scan(c.stats);
-if (alive &&
+}
-lint.isEnabled(Lint.LintCategory.FALLTHROUGH) &&
+resolveBreaks(tree, prevPendingExits);
-c.stats.nonEmpty() && l.tail.nonEmpty())
-log.warning(Lint.LintCategory.FALLTHROUGH,
-l.tail.head.pos(),
-"possible.fall-through.into.case");
-}
-if (!hasDefault) {
-alive = true;
-}
-alive |= resolveBreaks(tree, prevPendingExits);
 }
 public void visitTry(JCTry tree) {
 List<Type> caughtPrev = caught;
 List<Type> thrownPrev = thrown;
 }
 }
 }
 }
 }
-scanStat(tree.body);
+scan(tree.body);
 List<Type> thrownInTry = allowImprovedCatchAnalysis ?
 chk.union(thrown, List.of(syms.runtimeExceptionType, syms.errorType)) :
 thrown;
 thrown = thrownPrev;
 caught = caughtPrev;
-boolean aliveEnd = alive;
 List<Type> caughtInTry = List.nil();
 for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
-alive = true;
 JCVariableDecl param = l.head.param;
 List<JCExpression> subClauses = TreeInfo.isMultiCatch(l.head) ?
 ((JCTypeUnion)l.head.param.vartype).alternatives :
 List.of(l.head.param.vartype);
 List<Type> ctypes = List.nil();
 caughtInTry = chk.incl(exc, caughtInTry);
 }
 }
 scan(param);
 preciseRethrowTypes.put(param.sym, chk.intersect(ctypes, rethrownTypes));
-scanStat(l.head.body);
+scan(l.head.body);
 preciseRethrowTypes.remove(param.sym);
-aliveEnd |= alive;
 }
 if (tree.finalizer != null) {
 List<Type> savedThrown = thrown;
 thrown = List.nil();
 ListBuffer<FlowPendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
-alive = true;
+scan(tree.finalizer);
-scanStat(tree.finalizer);
+if (!tree.finallyCanCompleteNormally) {
-tree.finallyCanCompleteNormally = alive;
-if (!alive) {
 // discard exits and exceptions from try and finally
 thrown = chk.union(thrown, thrownPrev);
-if (lint.isEnabled(Lint.LintCategory.FINALLY)) {
-log.warning(Lint.LintCategory.FINALLY,
-TreeInfo.diagEndPos(tree.finalizer),
-"finally.cannot.complete");
-}
 } else {
 thrown = chk.union(thrown, chk.diff(thrownInTry, caughtInTry));
 thrown = chk.union(thrown, savedThrown);
 // FIX: this doesn't preserve source order of exits in catch
 // versus finally!
 while (exits.nonEmpty()) {
 pendingExits.append(exits.next());
 }
-alive = aliveEnd;
 }
 } else {
 thrown = chk.union(thrown, chk.diff(thrownInTry, caughtInTry));
-alive = aliveEnd;
 ListBuffer<FlowPendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
 while (exits.nonEmpty()) pendingExits.append(exits.next());
 }
 }
 @Override
 public void visitIf(JCIf tree) {
 scan(tree.cond);
-scanStat(tree.thenpart);
+scan(tree.thenpart);
 if (tree.elsepart != null) {
-boolean aliveAfterThen = alive;
+scan(tree.elsepart);
-alive = true;
-scanStat(tree.elsepart);
-alive = alive | aliveAfterThen;
-} else {
-alive = true;
 }
 }
 void checkCaughtType(DiagnosticPosition pos, Type exc, List<Type> thrownInTry, List<Type> caughtInTry) {
 if (chk.subset(exc, caughtInTry)) {
 recordExit(tree, new FlowPendingExit(tree, null));
 }
 public void visitReturn(JCReturn tree) {
 scan(tree.expr);
-// if not initial constructor, should markDead instead of recordExit
 recordExit(tree, new FlowPendingExit(tree, null));
 }
 public void visitThrow(JCThrow tree) {
 scan(tree.expr);
 *************************************************************************/
 /** Perform definite assignment/unassignment analysis on a tree.
 */
 public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
+analyzeTree(env, env.tree, make);
+}
+public void analyzeTree(Env<AttrContext> env, JCTree tree, TreeMaker make) {
 try {
 attrEnv = env;
-JCTree tree = env.tree;
 Flow.this.make = make;
 pendingExits = new ListBuffer<FlowPendingExit>();
 preciseRethrowTypes = new HashMap<Symbol, List<Type>>();
-alive = true;
 this.thrown = this.caught = null;
 this.classDef = null;
 scan(tree);
 } finally {
 pendingExits = null;
 /**
 * This pass implements (i) definite assignment analysis, which ensures that
 * each variable is assigned when used and (ii) definite unassignment analysis,
 * which ensures that no final variable is assigned more than once. This visitor
-* depends on the results of the liveliness analyzer.
+* depends on the results of the liveliness analyzer. This pass is also used to mark
+* effectively-final local variables/parameters.
 */
 class AssignAnalyzer extends BaseAnalyzer<AssignAnalyzer.AssignPendingExit> {
 /** The set of definitely assigned variables.
 */
 /** The list of unreferenced automatic resources.
 */
 Scope unrefdResources;
 /** Set when processing a loop body the second time for DU analysis. */
-boolean loopPassTwo = false;
+FlowKind flowKind = FlowKind.NORMAL;
+/** The starting position of the analysed tree */
+int startPos;
 class AssignPendingExit extends BaseAnalyzer.PendingExit {
 Bits exit_inits;
 Bits exit_uninits;
 /** Do we need to track init/uninit state of this symbol?
 *  I.e. is symbol either a local or a blank final variable?
 */
 boolean trackable(VarSymbol sym) {
 return
-(sym.owner.kind == MTH ||
+sym.pos >= startPos &&
+((sym.owner.kind == MTH ||
 ((sym.flags() & (FINAL | HASINIT | PARAMETER)) == FINAL &&
-classDef.sym.isEnclosedBy((ClassSymbol)sym.owner)));
+classDef.sym.isEnclosedBy((ClassSymbol)sym.owner))));
 }
 /** Initialize new trackable variable by setting its address field
 *  to the next available sequence number and entering it under that
 *  index into the vars array.
 if (nextadr == vars.length) {
 VarSymbol[] newvars = new VarSymbol[nextadr * 2];
 System.arraycopy(vars, 0, newvars, 0, nextadr);
 vars = newvars;
 }
+if ((sym.flags() & FINAL) == 0) {
+sym.flags_field |= EFFECTIVELY_FINAL;
+}
 sym.adr = nextadr;
 vars[nextadr] = sym;
 inits.excl(nextadr);
 uninits.incl(nextadr);
 nextadr++;
 /** Record an initialization of a trackable variable.
 */
 void letInit(DiagnosticPosition pos, VarSymbol sym) {
 if (sym.adr >= firstadr && trackable(sym)) {
-if ((sym.flags() & FINAL) != 0) {
+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,
+log.error(pos, flowKind.errKey, sym);
-loopPassTwo
-? "var.might.be.assigned.in.loop"
-: "var.might.already.be.assigned",
-sym);
-} else if (!inits.isMember(sym.adr)) {
-// reachable assignment
-uninits.excl(sym.adr);
-uninitsTry.excl(sym.adr);
 } else {
-//log.rawWarning(pos, "unreachable assignment");//DEBUG
+uninit(sym);
-uninits.excl(sym.adr);
 }
 }
 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)) {
+// reachable assignment
+uninits.excl(sym.adr);
+uninitsTry.excl(sym.adr);
+} else {
+//log.rawWarning(pos, "unreachable assignment");//DEBUG
+uninits.excl(sym.adr);
+}
+}
 /** If tree is either a simple name or of the form this.name or
 *  C.this.name, and tree represents a trackable variable,
 *  record an initialization of the variable.
 */
 nextadr = nextadrPrev;
 }
 public void visitDoLoop(JCDoWhileLoop tree) {
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
-boolean prevLoopPassTwo = loopPassTwo;
+FlowKind prevFlowKind = flowKind;
+flowKind = FlowKind.NORMAL;
+Bits initsSkip = null;
+Bits uninitsSkip = null;
 pendingExits = new ListBuffer<AssignPendingExit>();
 int prevErrors = log.nerrors;
 do {
 Bits uninitsEntry = uninits.dup();
 uninitsEntry.excludeFrom(nextadr);
 scan(tree.body);
 resolveContinues(tree);
 scanCond(tree.cond);
+if (!flowKind.isFinal()) {
+initsSkip = initsWhenFalse;
+uninitsSkip = uninitsWhenFalse;
+}
 if (log.nerrors !=  prevErrors ||
-loopPassTwo ||
+flowKind.isFinal() ||
 uninitsEntry.dup().diffSet(uninitsWhenTrue).nextBit(firstadr)==-1)
 break;
 inits = initsWhenTrue;
 uninits = uninitsEntry.andSet(uninitsWhenTrue);
-loopPassTwo = true;
+flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
-loopPassTwo = prevLoopPassTwo;
+flowKind = prevFlowKind;
-inits = initsWhenFalse;
+inits = initsSkip;
-uninits = uninitsWhenFalse;
+uninits = uninitsSkip;
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitWhileLoop(JCWhileLoop tree) {
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
-boolean prevLoopPassTwo = loopPassTwo;
+FlowKind prevFlowKind = flowKind;
-Bits initsCond;
+flowKind = FlowKind.NORMAL;
-Bits uninitsCond;
+Bits initsSkip = null;
+Bits uninitsSkip = null;
 pendingExits = new ListBuffer<AssignPendingExit>();
 int prevErrors = log.nerrors;
+Bits uninitsEntry = uninits.dup();
+uninitsEntry.excludeFrom(nextadr);
 do {
-Bits uninitsEntry = uninits.dup();
-uninitsEntry.excludeFrom(nextadr);
 scanCond(tree.cond);
-initsCond = initsWhenFalse;
+if (!flowKind.isFinal()) {
-uninitsCond = uninitsWhenFalse;
+initsSkip = initsWhenFalse;
+uninitsSkip = uninitsWhenFalse;
+}
 inits = initsWhenTrue;
 uninits = uninitsWhenTrue;
 scan(tree.body);
 resolveContinues(tree);
 if (log.nerrors != prevErrors ||
-loopPassTwo ||
+flowKind.isFinal() ||
 uninitsEntry.dup().diffSet(uninits).nextBit(firstadr) == -1)
 break;
 uninits = uninitsEntry.andSet(uninits);
-loopPassTwo = true;
+flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
-loopPassTwo = prevLoopPassTwo;
+flowKind = prevFlowKind;
-inits = initsCond;
+//a variable is DA/DU after the while statement, if it's DA/DU assuming the
-uninits = uninitsCond;
+//branch is not taken AND if it's DA/DU before any break statement
+inits = initsSkip;
+uninits = uninitsSkip;
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitForLoop(JCForLoop tree) {
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
-boolean prevLoopPassTwo = loopPassTwo;
+FlowKind prevFlowKind = flowKind;
+flowKind = FlowKind.NORMAL;
 int nextadrPrev = nextadr;
 scan(tree.init);
-Bits initsCond;
+Bits initsSkip = null;
-Bits uninitsCond;
+Bits uninitsSkip = null;
 pendingExits = new ListBuffer<AssignPendingExit>();
 int prevErrors = log.nerrors;
 do {
 Bits uninitsEntry = uninits.dup();
 uninitsEntry.excludeFrom(nextadr);
 if (tree.cond != null) {
 scanCond(tree.cond);
-initsCond = initsWhenFalse;
+if (!flowKind.isFinal()) {
-uninitsCond = uninitsWhenFalse;
+initsSkip = initsWhenFalse;
+uninitsSkip = uninitsWhenFalse;
+}
 inits = initsWhenTrue;
 uninits = uninitsWhenTrue;
-} else {
+} else if (!flowKind.isFinal()) {
-initsCond = inits.dup();
+initsSkip = inits.dup();
-initsCond.inclRange(firstadr, nextadr);
+initsSkip.inclRange(firstadr, nextadr);
-uninitsCond = uninits.dup();
+uninitsSkip = uninits.dup();
-uninitsCond.inclRange(firstadr, nextadr);
+uninitsSkip.inclRange(firstadr, nextadr);
 }
 scan(tree.body);
 resolveContinues(tree);
 scan(tree.step);
 if (log.nerrors != prevErrors ||
-loopPassTwo ||
+flowKind.isFinal() ||
 uninitsEntry.dup().diffSet(uninits).nextBit(firstadr) == -1)
 break;
 uninits = uninitsEntry.andSet(uninits);
-loopPassTwo = true;
+flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
-loopPassTwo = prevLoopPassTwo;
+flowKind = prevFlowKind;
-inits = initsCond;
+//a variable is DA/DU after a for loop, if it's DA/DU assuming the
-uninits = uninitsCond;
+//branch is not taken AND if it's DA/DU before any break statement
+inits = initsSkip;
+uninits = uninitsSkip;
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 public void visitForeachLoop(JCEnhancedForLoop tree) {
 visitVarDef(tree.var);
 ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
-boolean prevLoopPassTwo = loopPassTwo;
+FlowKind prevFlowKind = flowKind;
+flowKind = FlowKind.NORMAL;
 int nextadrPrev = nextadr;
 scan(tree.expr);
 Bits initsStart = inits.dup();
 Bits uninitsStart = uninits.dup();
 Bits uninitsEntry = uninits.dup();
 uninitsEntry.excludeFrom(nextadr);
 scan(tree.body);
 resolveContinues(tree);
 if (log.nerrors != prevErrors ||
-loopPassTwo ||
+flowKind.isFinal() ||
 uninitsEntry.dup().diffSet(uninits).nextBit(firstadr) == -1)
 break;
 uninits = uninitsEntry.andSet(uninits);
-loopPassTwo = true;
+flowKind = FlowKind.SPECULATIVE_LOOP;
 } while (true);
-loopPassTwo = prevLoopPassTwo;
+flowKind = prevFlowKind;
 inits = initsStart;
 uninits = uninitsStart.andSet(uninits);
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 recordExit(tree, new AssignPendingExit(tree, inits, uninits));
 }
 public void visitReturn(JCReturn tree) {
 scanExpr(tree.expr);
-// if not initial constructor, should markDead instead of recordExit
 recordExit(tree, new AssignPendingExit(tree, inits, uninits));
 }
 public void visitThrow(JCThrow tree) {
 scanExpr(tree.expr);
 uninits = uninitsExit;
 }
 public void visitAssign(JCAssign tree) {
 JCTree lhs = TreeInfo.skipParens(tree.lhs);
-if (!(lhs instanceof JCIdent)) scanExpr(lhs);
+if (!(lhs instanceof JCIdent)) {
+scanExpr(lhs);
+}
 scanExpr(tree.rhs);
 letInit(lhs);
 }
 public void visitAssignop(JCAssignOp tree) {
 *************************************************************************/
 /** Perform definite assignment/unassignment analysis on a tree.
 */
 public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
+analyzeTree(env, env.tree, make);
+}
+public void analyzeTree(Env<AttrContext> env, JCTree tree, TreeMaker make) {
 try {
 attrEnv = env;
-JCTree tree = env.tree;
 Flow.this.make = make;
+startPos = tree.pos().getStartPosition();
 inits = new Bits();
 uninits = new Bits();
 uninitsTry = new Bits();
 initsWhenTrue = initsWhenFalse =
 uninitsWhenTrue = uninitsWhenFalse = null;
 this.classDef = null;
 unrefdResources = new Scope(env.enclClass.sym);
 scan(tree);
 } finally {
 // note that recursive invocations of this method fail hard
+startPos = -1;
 inits = uninits = uninitsTry = null;
 initsWhenTrue = initsWhenFalse =
 uninitsWhenTrue = uninitsWhenFalse = null;
 if (vars != null) for (int i=0; i<vars.length; i++)
 vars[i] = null;
 this.classDef = null;
 unrefdResources = null;
 }
 }
 }
+/**
+* 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
+* AssignAnalyzer.
+*/
+class CaptureAnalyzer extends BaseAnalyzer<BaseAnalyzer.PendingExit> {
+JCTree currentTree; //local class or lambda
+@Override
+void markDead() {
+//do nothing
+}
+@SuppressWarnings("fallthrough")
+void checkEffectivelyFinal(DiagnosticPosition pos, VarSymbol sym) {
+if (currentTree != null &&
+sym.owner.kind == MTH &&
+sym.pos < currentTree.getStartPosition()) {
+switch (currentTree.getTag()) {
+case CLASSDEF:
+if (!allowEffectivelyFinalInInnerClasses) {
+if ((sym.flags() & FINAL) == 0) {
+reportInnerClsNeedsFinalError(pos, sym);
+}
+break;
+}
+case LAMBDA:
+if ((sym.flags() & (EFFECTIVELY_FINAL | FINAL)) == 0) {
+reportEffectivelyFinalError(pos, sym);
+}
+}
+}
+}
+@SuppressWarnings("fallthrough")
+void letInit(JCTree tree) {
+tree = TreeInfo.skipParens(tree);
+if (tree.hasTag(IDENT) || tree.hasTag(SELECT)) {
+Symbol sym = TreeInfo.symbol(tree);
+if (currentTree != null &&
+sym.kind == VAR &&
+sym.owner.kind == MTH &&
+((VarSymbol)sym).pos < currentTree.getStartPosition()) {
+switch (currentTree.getTag()) {
+case CLASSDEF:
+if (!allowEffectivelyFinalInInnerClasses) {
+reportInnerClsNeedsFinalError(tree, sym);
+break;
+}
+case LAMBDA:
+reportEffectivelyFinalError(tree, sym);
+}
+}
+}
+}
+void reportEffectivelyFinalError(DiagnosticPosition pos, Symbol sym) {
+String subKey = currentTree.hasTag(LAMBDA) ?
+"lambda"  : "inner.cls";
+log.error(pos, "cant.ref.non.effectively.final.var", sym, diags.fragment(subKey));
+}
+void reportInnerClsNeedsFinalError(DiagnosticPosition pos, Symbol sym) {
+log.error(pos,
+"local.var.accessed.from.icls.needs.final",
+sym);
+}
+/*************************************************************************
+* Visitor methods for statements and definitions
+*************************************************************************/
+/* ------------ Visitor methods for various sorts of trees -------------*/
+public void visitClassDef(JCClassDecl tree) {
+JCTree prevTree = currentTree;
+try {
+currentTree = tree.sym.isLocal() ? tree : null;
+super.visitClassDef(tree);
+} finally {
+currentTree = prevTree;
+}
+}
+@Override
+public void visitLambda(JCLambda tree) {
+JCTree prevTree = currentTree;
+try {
+currentTree = tree;
+super.visitLambda(tree);
+} finally {
+currentTree = prevTree;
+}
+}
+@Override
+public void visitIdent(JCIdent tree) {
+if (tree.sym.kind == VAR) {
+checkEffectivelyFinal(tree, (VarSymbol)tree.sym);
+}
+}
+public void visitAssign(JCAssign tree) {
+JCTree lhs = TreeInfo.skipParens(tree.lhs);
+if (!(lhs instanceof JCIdent)) {
+scan(lhs);
+}
+scan(tree.rhs);
+letInit(lhs);
+}
+public void visitAssignop(JCAssignOp tree) {
+scan(tree.lhs);
+scan(tree.rhs);
+letInit(tree.lhs);
+}
+public void visitUnary(JCUnary tree) {
+switch (tree.getTag()) {
+case PREINC: case POSTINC:
+case PREDEC: case POSTDEC:
+scan(tree.arg);
+letInit(tree.arg);
+break;
+default:
+scan(tree.arg);
+}
+}
+public void visitTopLevel(JCCompilationUnit tree) {
+// Do nothing for TopLevel since each class is visited individually
+}
+/**************************************************************************
+* main method
+*************************************************************************/
+/** Perform definite assignment/unassignment analysis on a tree.
+*/
+public void analyzeTree(Env<AttrContext> env, TreeMaker make) {
+analyzeTree(env, env.tree, make);
+}
+public void analyzeTree(Env<AttrContext> env, JCTree tree, TreeMaker make) {
+try {
+attrEnv = env;
+Flow.this.make = make;
+pendingExits = new ListBuffer<PendingExit>();
+scan(tree);
+} finally {
+pendingExits = null;
+Flow.this.make = null;
+}
+}
+}
 }

changeset 13439	3025d6ac1401
parent 13273	d597bc5e3935
child 13689	4d519199a6aa