/** Check statement */
Vset check(Environment env, Context ctx, Vset vset, Hashtable exp) {
checkLabel(env, ctx);
CheckContext newctx = new CheckContext(ctx, this);
// Vset vsExtra = vset.copy(); // See comment below.
ConditionVars cvars = cond.checkCondition(env, newctx, reach(env, vset), exp);
cond = convert(env, newctx, Type.tBoolean, cond);
// The following code, now deleted, was apparently an erroneous attempt
// at providing better error diagnostics. The comment read: 'If either
// the true clause or the false clause is unreachable, do a reasonable
// check on the child anyway.'
// Vset vsTrue = cvars.vsTrue.isDeadEnd() ? vsExtra : cvars.vsTrue;
// Vset vsFalse = cvars.vsFalse.isDeadEnd() ? vsExtra : cvars.vsFalse;
// Unfortunately, this violates the rules laid out in the JLS, and leads to
// blatantly incorrect results. For example, 'i' will not be recognized
// as definitely assigned following the statement 'if (true) i = 1;'.
// It is best to slavishly follow the JLS here. A cleverer approach could
// only correctly issue warnings, as JLS 16.2.6 is quite explicit, and it
// is OK for a dead branch of an if-statement to omit an assignment that
// would be required in the other branch. A complication: This code also
// had the effect of implementing the special-case rules for 'if-then' and
// 'if-then-else' in JLS 14.19, "Unreachable Statements". We now use
// 'Vset.clearDeadEnd' to remove the dead-end status of unreachable branches
// without affecting the definite-assignment status of the variables, thus
// maintaining a correct implementation of JLS 16.2.6. Fixes 4094353.
// Note that the code below will not consider the branches unreachable if
// the entire statement is unreachable. This is consistent with the error
// recovery policy that reports the only the first unreachable statement
// along an acyclic execution path.
Vset vsTrue = cvars.vsTrue.clearDeadEnd();
Vset vsFalse = cvars.vsFalse.clearDeadEnd();
vsTrue = ifTrue.check(env, newctx, vsTrue, exp);
if (ifFalse != null) vsFalse = ifFalse.check(env, newctx, vsFalse, exp);
vset = vsTrue.join(vsFalse.join(newctx.vsBreak));
return ctx.removeAdditionalVars(vset);
}
/** Check statement */
Vset check(Environment env, Context ctx, Vset vset, Hashtable exp) {
checkLabel(env, ctx);
vset = reach(env, vset);
if (expr != null) {
vset = expr.checkValue(env, ctx, vset, exp);
}
// Make sure the return isn't inside a static initializer
if (ctx.field.isInitializer()) {
env.error(where, "return.inside.static.initializer");
return DEAD_END;
}
// Check return type
if (ctx.field.getType().getReturnType().isType(TC_VOID)) {
if (expr != null) {
if (ctx.field.isConstructor()) {
env.error(where, "return.with.value.constr", ctx.field);
} else {
env.error(where, "return.with.value", ctx.field);
}
expr = null;
}
} else {
if (expr == null) {
env.error(where, "return.without.value", ctx.field);
} else {
expr = convert(env, ctx, ctx.field.getType().getReturnType(), expr);
}
}
CheckContext mctx = ctx.getReturnContext();
if (mctx != null) {
mctx.vsBreak = mctx.vsBreak.join(vset);
}
CheckContext exitctx = ctx.getTryExitContext();
if (exitctx != null) {
exitctx.vsTryExit = exitctx.vsTryExit.join(vset);
}
if (expr != null) {
// see if we are returning a value out of a try or synchronized
// statement. If so, find the outermost one. . . .
Node outerFinallyNode = null;
for (Context c = ctx; c != null; c = c.prev) {
if (c.node == null) {
continue;
}
if (c.node.op == METHOD) {
// Don't search outside current method. Fixes 4084230.
break;
}
if (c.node.op == SYNCHRONIZED) {
outerFinallyNode = c.node;
break;
} else if (c.node.op == FINALLY && ((CheckContext) c).vsContinue != null) {
outerFinallyNode = c.node;
}
}
if (outerFinallyNode != null) {
if (outerFinallyNode.op == FINALLY) {
((FinallyStatement) outerFinallyNode).needReturnSlot = true;
} else {
((SynchronizedStatement) outerFinallyNode).needReturnSlot = true;
}
}
}
return DEAD_END;
}
