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

equal deleted inserted replaced

-:899e1748bb17
+:515e4b33b335
 */
 //todo: one might eliminate uninits.andSets when monotonic
 package com.sun.tools.javac.comp;
+import java.util.HashMap;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 private final Symtab syms;
 private final Types types;
 private final Check chk;
 private       TreeMaker make;
 private       Lint lint;
+private final boolean allowRethrowAnalysis;
 public static Flow instance(Context context) {
 Flow instance = context.get(flowKey);
 if (instance == null)
 instance = new Flow(context);
 return instance;
 }
 protected Flow(Context context) {
 context.put(flowKey, this);
 names = Names.instance(context);
 log = Log.instance(context);
 syms = Symtab.instance(context);
 types = Types.instance(context);
 chk = Check.instance(context);
 lint = Lint.instance(context);
+Source source = Source.instance(context);
+allowRethrowAnalysis = source.allowMulticatch();
 }
 /** A flag that indicates whether the last statement could
 *  complete normally.
 */
 Bits inits;
 /** The set of definitely unassigned variables.
 */
 Bits uninits;
+HashMap<Symbol, List<Type>> multicatchTypes;
 /** The set of variables that are definitely unassigned everywhere
 *  in current try block. This variable is maintained lazily; it is
 *  updated only when something gets removed from uninits,
 *  typically by being assigned in reachable code.  To obtain the
 */
 void letInit(DiagnosticPosition pos, VarSymbol sym) {
 if (sym.adr >= firstadr && trackable(sym)) {
 if ((sym.flags() & FINAL) != 0) {
 if ((sym.flags() & PARAMETER) != 0) {
-log.error(pos, "final.parameter.may.not.be.assigned",
+if ((sym.flags() & DISJOINT) != 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,
 loopPassTwo
 ? "var.might.be.assigned.in.loop"
 : "var.might.already.be.assigned",
 public void visitTry(JCTry tree) {
 List<Type> caughtPrev = caught;
 List<Type> thrownPrev = thrown;
 thrown = List.nil();
-for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail)
+for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
-caught = chk.incl(l.head.param.type, caught);
+List<JCExpression> subClauses = TreeInfo.isMultiCatch(l.head) ?
+((JCTypeDisjoint)l.head.param.vartype).components :
+List.of(l.head.param.vartype);
+for (JCExpression ct : subClauses) {
+caught = chk.incl(ct.type, caught);
+}
+}
 Bits uninitsTryPrev = uninitsTry;
 ListBuffer<PendingExit> prevPendingExits = pendingExits;
 pendingExits = new ListBuffer<PendingExit>();
 Bits initsTry = inits.dup();
 uninitsTry = uninits.dup();
 List<Type> caughtInTry = List.nil();
 for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
 alive = true;
 JCVariableDecl param = l.head.param;
-Type exc = param.type;
+List<JCExpression> subClauses = TreeInfo.isMultiCatch(l.head) ?
-if (chk.subset(exc, caughtInTry)) {
+((JCTypeDisjoint)l.head.param.vartype).components :
-log.error(l.head.pos(),
+List.of(l.head.param.vartype);
-"except.already.caught", exc);
+List<Type> ctypes = List.nil();
-} else if (!chk.isUnchecked(l.head.pos(), exc) &&
+List<Type> rethrownTypes = chk.diff(thrownInTry, caughtInTry);
-exc.tsym != syms.throwableType.tsym &&
+for (JCExpression ct : subClauses) {
-exc.tsym != syms.exceptionType.tsym &&
+Type exc = ct.type;
-!chk.intersects(exc, thrownInTry)) {
+ctypes = ctypes.append(exc);
-log.error(l.head.pos(),
+if (types.isSameType(exc, syms.objectType))
-"except.never.thrown.in.try", exc);
+continue;
-}
+if (chk.subset(exc, caughtInTry)) {
-caughtInTry = chk.incl(exc, caughtInTry);
+log.error(l.head.pos(),
+"except.already.caught", exc);
+} else if (!chk.isUnchecked(l.head.pos(), exc) &&
+exc.tsym != syms.throwableType.tsym &&
+exc.tsym != syms.exceptionType.tsym &&
+!chk.intersects(exc, thrownInTry)) {
+log.error(l.head.pos(),
+"except.never.thrown.in.try", exc);
+}
+caughtInTry = chk.incl(exc, caughtInTry);
+}
 inits = initsTry.dup();
 uninits = uninitsTry.dup();
 scan(param);
 inits.incl(param.sym.adr);
 uninits.excl(param.sym.adr);
+multicatchTypes.put(param.sym, chk.intersect(ctypes, rethrownTypes));
 scanStat(l.head.body);
 initsEnd.andSet(inits);
 uninitsEnd.andSet(uninits);
 nextadr = nextadrCatch;
+multicatchTypes.remove(param.sym);
 aliveEnd |= alive;
 }
 if (tree.finalizer != null) {
 List<Type> savedThrown = thrown;
 thrown = List.nil();
 recordExit(tree);
 }
 public void visitThrow(JCThrow tree) {
 scanExpr(tree.expr);
-markThrown(tree, tree.expr.type);
+Symbol sym = TreeInfo.symbol(tree.expr);
+if (sym != null &&
+sym.kind == VAR &&
+(sym.flags() & FINAL) != 0 &&
+multicatchTypes.get(sym) != null &&
+allowRethrowAnalysis) {
+for (Type t : multicatchTypes.get(sym)) {
+markThrown(tree, t);
+}
+}
+else {
+markThrown(tree, tree.expr.type);
+}
 markDead();
 }
 public void visitApply(JCMethodInvocation tree) {
 scanExpr(tree.meth);
 for (int i=0; i<vars.length; i++)
 vars[i] = null;
 firstadr = 0;
 nextadr = 0;
 pendingExits = new ListBuffer<PendingExit>();
+multicatchTypes = new HashMap<Symbol, List<Type>>();
 alive = true;
 this.thrown = this.caught = null;
 this.classDef = null;
 scan(tree);
 } finally {

changeset 5492	515e4b33b335
parent 3149	0cd06d598d6f
child 5520	86e4b9a9da40