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

equal deleted inserted replaced

-:df065f8356d7
+:e4ba5414c8b4
 /**
 * Base visitor class for all visitors implementing dataflow analysis logic.
 * This class define the shared logic for handling jumps (break/continue statements).
 */
-static abstract class BaseAnalyzer<P extends BaseAnalyzer.PendingExit> extends TreeScanner {
+static abstract class BaseAnalyzer extends TreeScanner {
 enum JumpKind {
 BREAK(JCTree.Tag.BREAK) {
 @Override
 JCTree getTarget(JCTree tree) {
 }
 /** The currently pending exits that go from current inner blocks
 *  to an enclosing block, in source order.
 */
-ListBuffer<P> pendingExits;
+ListBuffer<PendingExit> pendingExits;
 /** A pending exit.  These are the statements return, break, and
 *  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
 }
 abstract void markDead();
 /** Record an outward transfer of control. */
-void recordExit(P pe) {
+void recordExit(PendingExit pe) {
 pendingExits.append(pe);
 markDead();
 }
 /** Resolve all jumps of this statement. */
 private Liveness resolveJump(JCTree tree,
-ListBuffer<P> oldPendingExits,
+ListBuffer<PendingExit> oldPendingExits,
 JumpKind jk) {
 boolean resolved = false;
-List<P> exits = pendingExits.toList();
+List<PendingExit> exits = pendingExits.toList();
 pendingExits = oldPendingExits;
 for (; exits.nonEmpty(); exits = exits.tail) {
-P exit = exits.head;
+PendingExit exit = exits.head;
 if (exit.tree.hasTag(jk.treeTag) &&
 jk.getTarget(exit.tree) == tree) {
 exit.resolveJump();
 resolved = true;
 } else {
 return Liveness.from(resolved);
 }
 /** Resolve all continues of this statement. */
 Liveness resolveContinues(JCTree tree) {
-return resolveJump(tree, new ListBuffer<P>(), JumpKind.CONTINUE);
+return resolveJump(tree, new ListBuffer<PendingExit>(), JumpKind.CONTINUE);
 }
 /** Resolve all breaks of this statement. */
-Liveness resolveBreaks(JCTree tree, ListBuffer<P> oldPendingExits) {
+Liveness resolveBreaks(JCTree tree, ListBuffer<PendingExit> oldPendingExits) {
 return resolveJump(tree, oldPendingExits, JumpKind.BREAK);
 }
 @Override
 public void scan(JCTree tree) {
 * This pass implements the first step of the dataflow analysis, namely
 * the liveness analysis check. This checks that every statement is reachable.
 * The output of this analysis pass are used by other analyzers. This analyzer
 * sets the 'finallyCanCompleteNormally' field in the JCTry class.
 */
-class AliveAnalyzer extends BaseAnalyzer<BaseAnalyzer.PendingExit> {
+class AliveAnalyzer extends BaseAnalyzer {
 /** A flag that indicates whether the last statement could
 *  complete normally.
 */
 private Liveness alive;
 * 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> {
+class FlowAnalyzer extends BaseAnalyzer {
 /** A flag that indicates whether the last statement could
 *  complete normally.
 */
 HashMap<Symbol, List<Type>> preciseRethrowTypes;
 /** The list of exceptions that are either caught or declared to be
 *  thrown.
 */
 List<Type> caught;
-class FlowPendingExit extends BaseAnalyzer.PendingExit {
+class ThrownPendingExit extends BaseAnalyzer.PendingExit {
 Type thrown;
-FlowPendingExit(JCTree tree, Type thrown) {
+ThrownPendingExit(JCTree tree, Type thrown) {
 super(tree);
 this.thrown = thrown;
 }
 }
 /*-------------------- Exceptions ----------------------*/
 /** Complain that pending exceptions are not caught.
 */
 void errorUncaught() {
-for (FlowPendingExit exit = pendingExits.next();
+for (PendingExit exit = pendingExits.next();
 exit != null;
 exit = pendingExits.next()) {
+Assert.check(exit instanceof ThrownPendingExit);
+ThrownPendingExit thrownExit = (ThrownPendingExit) exit;
 if (classDef != null &&
 classDef.pos == exit.tree.pos) {
 log.error(exit.tree.pos(),
-Errors.UnreportedExceptionDefaultConstructor(exit.thrown));
+Errors.UnreportedExceptionDefaultConstructor(thrownExit.thrown));
 } else if (exit.tree.hasTag(VARDEF) &&
 ((JCVariableDecl)exit.tree).sym.isResourceVariable()) {
 log.error(exit.tree.pos(),
-Errors.UnreportedExceptionImplicitClose(exit.thrown,
+Errors.UnreportedExceptionImplicitClose(thrownExit.thrown,
 ((JCVariableDecl)exit.tree).sym.name));
 } else {
 log.error(exit.tree.pos(),
-Errors.UnreportedExceptionNeedToCatchOrThrow(exit.thrown));
+Errors.UnreportedExceptionNeedToCatchOrThrow(thrownExit.thrown));
 }
 }
 }
 /** Record that exception is potentially thrown and check that it
 *  is caught.
 */
 void markThrown(JCTree tree, Type exc) {
 if (!chk.isUnchecked(tree.pos(), exc)) {
 if (!chk.isHandled(exc, caught)) {
-pendingExits.append(new FlowPendingExit(tree, exc));
+pendingExits.append(new ThrownPendingExit(tree, exc));
 }
 thrown = chk.incl(exc, thrown);
 }
 }
 if (tree.sym == null) return;
 JCClassDecl classDefPrev = classDef;
 List<Type> thrownPrev = thrown;
 List<Type> caughtPrev = caught;
-ListBuffer<FlowPendingExit> pendingExitsPrev = pendingExits;
+ListBuffer<PendingExit> pendingExitsPrev = pendingExits;
 Lint lintPrev = lint;
 boolean anonymousClass = tree.name == names.empty;
 pendingExits = new ListBuffer<>();
 if (!anonymousClass) {
 caught = List.nil();
 // else we are in an instance initializer block;
 // leave caught unchanged.
 scan(tree.body);
-List<FlowPendingExit> exits = pendingExits.toList();
+List<PendingExit> exits = pendingExits.toList();
 pendingExits = new ListBuffer<>();
 while (exits.nonEmpty()) {
-FlowPendingExit exit = exits.head;
+PendingExit exit = exits.head;
 exits = exits.tail;
-if (exit.thrown == null) {
+if (!(exit instanceof ThrownPendingExit)) {
 Assert.check(exit.tree.hasTag(RETURN));
 } else {
 // uncaught throws will be reported later
 pendingExits.append(exit);
 }
 public void visitBlock(JCBlock tree) {
 scan(tree.stats);
 }
 public void visitDoLoop(JCDoWhileLoop tree) {
-ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 scan(tree.body);
 resolveContinues(tree);
 scan(tree.cond);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitWhileLoop(JCWhileLoop tree) {
-ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 scan(tree.cond);
 scan(tree.body);
 resolveContinues(tree);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitForLoop(JCForLoop tree) {
-ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 scan(tree.init);
 pendingExits = new ListBuffer<>();
 if (tree.cond != null) {
 scan(tree.cond);
 }
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitForeachLoop(JCEnhancedForLoop tree) {
 visitVarDef(tree.var);
-ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 scan(tree.expr);
 pendingExits = new ListBuffer<>();
 scan(tree.body);
 resolveContinues(tree);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitLabelled(JCLabeledStatement tree) {
-ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 scan(tree.body);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitSwitchExpression(JCSwitchExpression tree) {
 handleSwitch(tree, tree.selector, tree.cases);
 }
 private void handleSwitch(JCTree tree, JCExpression selector, List<JCCase> cases) {
-ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 scan(selector);
 for (List<JCCase> l = cases; l.nonEmpty(); l = l.tail) {
 JCCase c = l.head;
 scan(c.pats);
 for (JCExpression ct : subClauses) {
 caught = chk.incl(ct.type, caught);
 }
 }
-ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 for (JCTree resource : tree.resources) {
 if (resource instanceof JCVariableDecl) {
 JCVariableDecl vdecl = (JCVariableDecl) resource;
 visitVarDef(vdecl);
 preciseRethrowTypes.remove(param.sym);
 }
 if (tree.finalizer != null) {
 List<Type> savedThrown = thrown;
 thrown = List.nil();
-ListBuffer<FlowPendingExit> exits = pendingExits;
+ListBuffer<PendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
 scan(tree.finalizer);
 if (!tree.finallyCanCompleteNormally) {
 // discard exits and exceptions from try and finally
 thrown = chk.union(thrown, thrownPrev);
 pendingExits.append(exits.next());
 }
 }
 } else {
 thrown = chk.union(thrown, chk.diff(thrownInTry, caughtInTry));
-ListBuffer<FlowPendingExit> exits = pendingExits;
+ListBuffer<PendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
 while (exits.nonEmpty()) pendingExits.append(exits.next());
 }
 }
 }
 public void visitBreak(JCBreak tree) {
 if (tree.isValueBreak())
 scan(tree.value);
-recordExit(new FlowPendingExit(tree, null));
+recordExit(new PendingExit(tree));
 }
 public void visitContinue(JCContinue tree) {
-recordExit(new FlowPendingExit(tree, null));
+recordExit(new PendingExit(tree));
 }
 public void visitReturn(JCReturn tree) {
 scan(tree.expr);
-recordExit(new FlowPendingExit(tree, null));
+recordExit(new PendingExit(tree));
 }
 public void visitThrow(JCThrow tree) {
 scan(tree.expr);
 Symbol sym = TreeInfo.symbol(tree.expr);
 tree.type.isErroneous()) {
 return;
 }
 List<Type> prevCaught = caught;
 List<Type> prevThrown = thrown;
-ListBuffer<FlowPendingExit> prevPending = pendingExits;
+ListBuffer<PendingExit> prevPending = pendingExits;
 try {
 pendingExits = new ListBuffer<>();
 caught = tree.getDescriptorType(types).getThrownTypes();
 thrown = List.nil();
 scan(tree.body);
-List<FlowPendingExit> exits = pendingExits.toList();
+List<PendingExit> exits = pendingExits.toList();
 pendingExits = new ListBuffer<>();
 while (exits.nonEmpty()) {
-FlowPendingExit exit = exits.head;
+PendingExit exit = exits.head;
 exits = exits.tail;
-if (exit.thrown == null) {
+if (!(exit instanceof ThrownPendingExit)) {
 Assert.check(exit.tree.hasTag(RETURN));
 } else {
 // uncaught throws will be reported later
 pendingExits.append(exit);
 }
 tree.type.isErroneous()) || inLambda) {
 return;
 }
 List<Type> prevCaught = caught;
 List<Type> prevThrown = thrown;
-ListBuffer<FlowPendingExit> prevPending = pendingExits;
+ListBuffer<PendingExit> prevPending = pendingExits;
 inLambda = true;
 try {
 pendingExits = new ListBuffer<>();
 caught = List.of(syms.throwableType);
 thrown = List.nil();
 * 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 class AssignAnalyzer extends BaseAnalyzer<AssignAnalyzer.AssignPendingExit> {
+public class AssignAnalyzer extends BaseAnalyzer {
 /** The set of definitely assigned variables.
 */
 final Bits inits;
 }
 JCClassDecl classDefPrev = classDef;
 int firstadrPrev = firstadr;
 int nextadrPrev = nextadr;
-ListBuffer<AssignPendingExit> pendingExitsPrev = pendingExits;
+ListBuffer<PendingExit> pendingExitsPrev = pendingExits;
 pendingExits = new ListBuffer<>();
 if (tree.name != names.empty) {
 firstadr = nextadr;
 }
 checkInit(TreeInfo.diagEndPos(tree.body), var);
 }
 }
 }
 }
-List<AssignPendingExit> exits = pendingExits.toList();
+List<PendingExit> exits = pendingExits.toList();
 pendingExits = new ListBuffer<>();
 while (exits.nonEmpty()) {
-AssignPendingExit exit = exits.head;
+PendingExit exit = exits.head;
 exits = exits.tail;
 Assert.check(exit.tree.hasTag(RETURN), exit.tree);
 if (isInitialConstructor) {
-inits.assign(exit.exit_inits);
+Assert.check(exit instanceof AssignPendingExit);
+inits.assign(((AssignPendingExit) exit).exit_inits);
 for (int i = firstadr; i < nextadr; i++) {
 checkInit(exit.tree.pos(), vardecls[i].sym);
 }
 }
 }
 scan(tree.stats);
 nextadr = nextadrPrev;
 }
 public void visitDoLoop(JCDoWhileLoop tree) {
-ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 final Bits initsSkip = new Bits(true);
 final Bits uninitsSkip = new Bits(true);
 pendingExits = new ListBuffer<>();
 uninits.assign(uninitsSkip);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitWhileLoop(JCWhileLoop tree) {
-ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 final Bits initsSkip = new Bits(true);
 final Bits uninitsSkip = new Bits(true);
 pendingExits = new ListBuffer<>();
 uninits.assign(uninitsSkip);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitForLoop(JCForLoop tree) {
-ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 int nextadrPrev = nextadr;
 scan(tree.init);
 final Bits initsSkip = new Bits(true);
 }
 public void visitForeachLoop(JCEnhancedForLoop tree) {
 visitVarDef(tree.var);
-ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 FlowKind prevFlowKind = flowKind;
 flowKind = FlowKind.NORMAL;
 int nextadrPrev = nextadr;
 scan(tree.expr);
 final Bits initsStart = new Bits(inits);
 resolveBreaks(tree, prevPendingExits);
 nextadr = nextadrPrev;
 }
 public void visitLabelled(JCLabeledStatement tree) {
-ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 scan(tree.body);
 resolveBreaks(tree, prevPendingExits);
 }
 public void visitSwitchExpression(JCSwitchExpression tree) {
 handleSwitch(tree, tree.selector, tree.cases);
 }
 private void handleSwitch(JCTree tree, JCExpression selector, List<JCCase> cases) {
-ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 int nextadrPrev = nextadr;
 scanExpr(selector);
 final Bits initsSwitch = new Bits(inits);
 final Bits uninitsSwitch = new Bits(uninits);
 }
 public void visitTry(JCTry tree) {
 ListBuffer<JCVariableDecl> resourceVarDecls = new ListBuffer<>();
 final Bits uninitsTryPrev = new Bits(uninitsTry);
-ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
+ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<>();
 final Bits initsTry = new Bits(inits);
 uninitsTry.assign(uninits);
 for (JCTree resource : tree.resources) {
 if (resource instanceof JCVariableDecl) {
 nextadr = nextadrCatch;
 }
 if (tree.finalizer != null) {
 inits.assign(initsTry);
 uninits.assign(uninitsTry);
-ListBuffer<AssignPendingExit> exits = pendingExits;
+ListBuffer<PendingExit> 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()) {
-AssignPendingExit exit = exits.next();
+PendingExit exit = exits.next();
-if (exit.exit_inits != null) {
+if (exit instanceof AssignPendingExit) {
-exit.exit_inits.orSet(inits);
+((AssignPendingExit) exit).exit_inits.orSet(inits);
-exit.exit_uninits.andSet(uninits);
+((AssignPendingExit) exit).exit_uninits.andSet(uninits);
 }
 pendingExits.append(exit);
 }
 inits.orSet(initsEnd);
 }
 } else {
 inits.assign(initsEnd);
 uninits.assign(uninitsEnd);
-ListBuffer<AssignPendingExit> exits = pendingExits;
+ListBuffer<PendingExit> exits = pendingExits;
 pendingExits = prevPendingExits;
 while (exits.nonEmpty()) pendingExits.append(exits.next());
 }
 uninitsTry.andSet(uninitsTryPrev).andSet(uninits);
 }
 }
 }
 @Override
 public void visitBreak(JCBreak tree) {
-if (tree.isValueBreak())
+if (tree.isValueBreak()) {
+if (tree.target.hasTag(SWITCH_EXPRESSION)) {
+JCSwitchExpression expr = (JCSwitchExpression) tree.target;
+if (expr.type.hasTag(BOOLEAN)) {
+scanCond(tree.value);
+Bits initsAfterBreakWhenTrue = new Bits(initsWhenTrue);
+Bits initsAfterBreakWhenFalse = new Bits(initsWhenFalse);
+Bits uninitsAfterBreakWhenTrue = new Bits(uninitsWhenTrue);
+Bits uninitsAfterBreakWhenFalse = new Bits(uninitsWhenFalse);
+PendingExit exit = new PendingExit(tree) {
+@Override
+void resolveJump() {
+if (!inits.isReset()) {
+split(true);
+}
+initsWhenTrue.andSet(initsAfterBreakWhenTrue);
+initsWhenFalse.andSet(initsAfterBreakWhenFalse);
+uninitsWhenTrue.andSet(uninitsAfterBreakWhenTrue);
+uninitsWhenFalse.andSet(uninitsAfterBreakWhenFalse);
+}
+};
+merge();
+recordExit(exit);
+return ;
+}
+}
 scan(tree.value);
+}
 recordExit(new AssignPendingExit(tree, inits, uninits));
 }
 @Override
 public void visitContinue(JCContinue tree) {
 public void visitLambda(JCLambda tree) {
 final Bits prevUninits = new Bits(uninits);
 final Bits prevInits = new Bits(inits);
 int returnadrPrev = returnadr;
 int nextadrPrev = nextadr;
-ListBuffer<AssignPendingExit> prevPending = pendingExits;
+ListBuffer<PendingExit> prevPending = pendingExits;
 try {
 returnadr = nextadr;
 pendingExits = new ListBuffer<>();
 for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
 JCVariableDecl def = l.head;
 * Additional this also checks that every variable that is used as an operand to
 * try-with-resources is 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> {
+class CaptureAnalyzer extends BaseAnalyzer {
 JCTree currentTree; //local class or lambda
 @Override
 void markDead() {

changeset 52794	e4ba5414c8b4
parent 52635	6938c8ef179a
child 52936	9745e4e36dd1