2623 lines
102 KiB
Java
2623 lines
102 KiB
Java
/*
|
|
* 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
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
//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;
|
|
|
|
import com.sun.tools.javac.code.Symbol.*;
|
|
import com.sun.tools.javac.tree.JCTree.*;
|
|
|
|
import static com.sun.tools.javac.code.Flags.*;
|
|
import static com.sun.tools.javac.code.Flags.BLOCK;
|
|
import static com.sun.tools.javac.code.Kinds.*;
|
|
import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
|
|
import static com.sun.tools.javac.code.TypeTag.VOID;
|
|
import static com.sun.tools.javac.tree.JCTree.Tag.*;
|
|
|
|
/** This pass implements dataflow analysis for Java programs though
|
|
* different AST visitor steps. Liveness analysis (see AliveAnalyzer) checks that
|
|
* every statement is reachable. Exception analysis (see FlowAnalyzer) ensures that
|
|
* every checked exception that is thrown is declared or caught. Definite assignment analysis
|
|
* (see AssignAnalyzer) ensures that each variable is assigned when used. Definite
|
|
* unassignment analysis (see AssignAnalyzer) in ensures that no final variable
|
|
* is assigned more than once. Finally, local variable capture analysis (see CaptureAnalyzer)
|
|
* determines that local variables accessed within the scope of an inner class/lambda
|
|
* 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.
|
|
*
|
|
* <p>First, there is no accommodation for a finally clause that cannot
|
|
* complete normally. For liveness analysis, an intervening finally
|
|
* clause can cause a break, continue, or return not to reach its
|
|
* target. For exception analysis, an intervening finally clause can
|
|
* cause any exception to be "caught". For DA/DU analysis, the finally
|
|
* clause can prevent a transfer of control from propagating DA/DU
|
|
* state to the target. In addition, code in the finally clause can
|
|
* affect the DA/DU status of variables.
|
|
*
|
|
* <p>For try statements, we introduce the idea of a variable being
|
|
* definitely unassigned "everywhere" in a block. A variable V is
|
|
* "unassigned everywhere" in a block iff it is unassigned at the
|
|
* beginning of the block and there is no reachable assignment to V
|
|
* in the block. An assignment V=e is reachable iff V is not DA
|
|
* after e. Then we can say that V is DU at the beginning of the
|
|
* catch block iff V is DU everywhere in the try block. Similarly, V
|
|
* is DU at the beginning of the finally block iff V is DU everywhere
|
|
* in the try block and in every catch block. Specifically, the
|
|
* following bullet is added to 16.2.2
|
|
* <pre>
|
|
* V is <em>unassigned everywhere</em> in a block if it is
|
|
* unassigned before the block and there is no reachable
|
|
* assignment to V within the block.
|
|
* </pre>
|
|
* <p>In 16.2.15, the third bullet (and all of its sub-bullets) for all
|
|
* try blocks is changed to
|
|
* <pre>
|
|
* V is definitely unassigned before a catch block iff V is
|
|
* definitely unassigned everywhere in the try block.
|
|
* </pre>
|
|
* <p>The last bullet (and all of its sub-bullets) for try blocks that
|
|
* have a finally block is changed to
|
|
* <pre>
|
|
* V is definitely unassigned before the finally block iff
|
|
* V is definitely unassigned everywhere in the try block
|
|
* and everywhere in each catch block of the try statement.
|
|
* </pre>
|
|
* <p>In addition,
|
|
* <pre>
|
|
* V is definitely assigned at the end of a constructor iff
|
|
* V is definitely assigned after the block that is the body
|
|
* of the constructor and V is definitely assigned at every
|
|
* return that can return from the constructor.
|
|
* </pre>
|
|
* <p>In addition, each continue statement with the loop as its target
|
|
* is treated as a jump to the end of the loop body, and "intervening"
|
|
* finally clauses are treated as follows: V is DA "due to the
|
|
* continue" iff V is DA before the continue statement or V is DA at
|
|
* the end of any intervening finally block. V is DU "due to the
|
|
* continue" iff any intervening finally cannot complete normally or V
|
|
* is DU at the end of every intervening finally block. This "due to
|
|
* the continue" concept is then used in the spec for the loops.
|
|
*
|
|
* <p>Similarly, break statements must consider intervening finally
|
|
* blocks. For liveness analysis, a break statement for which any
|
|
* intervening finally cannot complete normally is not considered to
|
|
* cause the target statement to be able to complete normally. Then
|
|
* we say V is DA "due to the break" iff V is DA before the break or
|
|
* V is DA at the end of any intervening finally block. V is DU "due
|
|
* to the break" iff any intervening finally cannot complete normally
|
|
* or V is DU at the break and at the end of every intervening
|
|
* finally block. (I suspect this latter condition can be
|
|
* simplified.) This "due to the break" is then used in the spec for
|
|
* all statements that can be "broken".
|
|
*
|
|
* <p>The return statement is treated similarly. V is DA "due to a
|
|
* return statement" iff V is DA before the return statement or V is
|
|
* DA at the end of any intervening finally block. Note that we
|
|
* don't have to worry about the return expression because this
|
|
* concept is only used for construcrors.
|
|
*
|
|
* <p>There is no spec in the JLS for when a variable is definitely
|
|
* assigned at the end of a constructor, which is needed for final
|
|
* fields (8.3.1.2). We implement the rule that V is DA at the end
|
|
* of the constructor iff it is DA and the end of the body of the
|
|
* constructor and V is DA "due to" every return of the constructor.
|
|
*
|
|
* <p>Intervening finally blocks similarly affect exception analysis. An
|
|
* intervening finally that cannot complete normally allows us to ignore
|
|
* an otherwise uncaught exception.
|
|
*
|
|
* <p>To implement the semantics of intervening finally clauses, all
|
|
* nonlocal transfers (break, continue, return, throw, method call that
|
|
* can throw a checked exception, and a constructor invocation that can
|
|
* thrown a checked exception) are recorded in a queue, and removed
|
|
* from the queue when we complete processing the target of the
|
|
* nonlocal transfer. This allows us to modify the queue in accordance
|
|
* with the above rules when we encounter a finally clause. The only
|
|
* exception to this [no pun intended] is that checked exceptions that
|
|
* are known to be caught or declared to be caught in the enclosing
|
|
* method are not recorded in the queue, but instead are recorded in a
|
|
* global variable "{@code Set<Type> thrown}" that records the type of all
|
|
* exceptions that can be thrown.
|
|
*
|
|
* <p>Other minor issues the treatment of members of other classes
|
|
* (always considered DA except that within an anonymous class
|
|
* constructor, where DA status from the enclosing scope is
|
|
* preserved), treatment of the case expression (V is DA before the
|
|
* case expression iff V is DA after the switch expression),
|
|
* treatment of variables declared in a switch block (the implied
|
|
* DA/DU status after the switch expression is DU and not DA for
|
|
* variables defined in a switch block), the treatment of boolean ?:
|
|
* expressions (The JLS rules only handle b and c non-boolean; the
|
|
* new rule is that if b and c are boolean valued, then V is
|
|
* (un)assigned after a?b:c when true/false iff V is (un)assigned
|
|
* after b when true/false and V is (un)assigned after c when
|
|
* true/false).
|
|
*
|
|
* <p>There is the remaining question of what syntactic forms constitute a
|
|
* reference to a variable. It is conventional to allow this.x on the
|
|
* left-hand-side to initialize a final instance field named x, yet
|
|
* this.x isn't considered a "use" when appearing on a right-hand-side
|
|
* in most implementations. Should parentheses affect what is
|
|
* considered a variable reference? The simplest rule would be to
|
|
* allow unqualified forms only, parentheses optional, and phase out
|
|
* support for assigning to a final field via this.x.
|
|
*
|
|
* <p><b>This is NOT part of any supported API.
|
|
* If you write code that depends on this, you do so at your own risk.
|
|
* This code and its internal interfaces are subject to change or
|
|
* deletion without notice.</b>
|
|
*/
|
|
public class Flow {
|
|
protected static final Context.Key<Flow> flowKey =
|
|
new Context.Key<Flow>();
|
|
|
|
private final Names names;
|
|
private final Log log;
|
|
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;
|
|
private final boolean enforceThisDotInit;
|
|
|
|
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);
|
|
new FlowAnalyzer().analyzeTree(env, make);
|
|
new CaptureAnalyzer().analyzeTree(env, make);
|
|
}
|
|
|
|
public void analyzeLambda(Env<AttrContext> env, JCLambda that, TreeMaker make, boolean speculative) {
|
|
Log.DiagnosticHandler diagHandler = null;
|
|
//we need to disable diagnostics temporarily; the problem is that if
|
|
//a lambda expression contains e.g. an unreachable statement, an error
|
|
//message will be reported and will cause compilation to skip the flow analyis
|
|
//step - if we suppress diagnostics, we won't stop at Attr for flow-analysis
|
|
//related errors, which will allow for more errors to be detected
|
|
if (!speculative) {
|
|
diagHandler = new Log.DiscardDiagnosticHandler(log);
|
|
}
|
|
try {
|
|
new AliveAnalyzer().analyzeTree(env, that, make);
|
|
} finally {
|
|
if (!speculative) {
|
|
log.popDiagnosticHandler(diagHandler);
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<Type> analyzeLambdaThrownTypes(final Env<AttrContext> env,
|
|
JCLambda that, TreeMaker make) {
|
|
//we need to disable diagnostics temporarily; the problem is that if
|
|
//a lambda expression contains e.g. an unreachable statement, an error
|
|
//message will be reported and will cause compilation to skip the flow analyis
|
|
//step - if we suppress diagnostics, we won't stop at Attr for flow-analysis
|
|
//related errors, which will allow for more errors to be detected
|
|
Log.DiagnosticHandler diagHandler = new Log.DiscardDiagnosticHandler(log);
|
|
try {
|
|
new AssignAnalyzer() {
|
|
Scope enclosedSymbols = new Scope(env.enclClass.sym);
|
|
@Override
|
|
public void visitVarDef(JCVariableDecl tree) {
|
|
enclosedSymbols.enter(tree.sym);
|
|
super.visitVarDef(tree);
|
|
}
|
|
@Override
|
|
protected boolean trackable(VarSymbol sym) {
|
|
return enclosedSymbols.includes(sym) &&
|
|
sym.owner.kind == MTH;
|
|
}
|
|
}.analyzeTree(env, that);
|
|
LambdaFlowAnalyzer flowAnalyzer = new LambdaFlowAnalyzer();
|
|
flowAnalyzer.analyzeTree(env, that, make);
|
|
return flowAnalyzer.inferredThrownTypes;
|
|
} finally {
|
|
log.popDiagnosticHandler(diagHandler);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
|
|
final String errKey;
|
|
final 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);
|
|
log = Log.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();
|
|
allowEffectivelyFinalInInnerClasses = source.allowEffectivelyFinalInInnerClasses();
|
|
enforceThisDotInit = source.enforceThisDotInit();
|
|
}
|
|
|
|
/**
|
|
* 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 {
|
|
|
|
enum JumpKind {
|
|
BREAK(JCTree.Tag.BREAK) {
|
|
@Override
|
|
JCTree getTarget(JCTree tree) {
|
|
return ((JCBreak)tree).target;
|
|
}
|
|
},
|
|
CONTINUE(JCTree.Tag.CONTINUE) {
|
|
@Override
|
|
JCTree getTarget(JCTree tree) {
|
|
return ((JCContinue)tree).target;
|
|
}
|
|
};
|
|
|
|
final JCTree.Tag treeTag;
|
|
|
|
private JumpKind(Tag treeTag) {
|
|
this.treeTag = treeTag;
|
|
}
|
|
|
|
abstract JCTree getTarget(JCTree tree);
|
|
}
|
|
|
|
/** The currently pending exits that go from current inner blocks
|
|
* to an enclosing block, in source order.
|
|
*/
|
|
ListBuffer<P> 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
|
|
* try-finally whose finally block cannot complete normally.
|
|
*/
|
|
static class PendingExit {
|
|
JCTree tree;
|
|
|
|
PendingExit(JCTree tree) {
|
|
this.tree = tree;
|
|
}
|
|
|
|
void resolveJump() {
|
|
//do nothing
|
|
}
|
|
}
|
|
|
|
abstract void markDead();
|
|
|
|
/** Record an outward transfer of control. */
|
|
void recordExit(P pe) {
|
|
pendingExits.append(pe);
|
|
markDead();
|
|
}
|
|
|
|
/** Resolve all jumps of this statement. */
|
|
private boolean resolveJump(JCTree tree,
|
|
ListBuffer<P> oldPendingExits,
|
|
JumpKind jk) {
|
|
boolean resolved = false;
|
|
List<P> exits = pendingExits.toList();
|
|
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();
|
|
resolved = true;
|
|
} else {
|
|
pendingExits.append(exit);
|
|
}
|
|
}
|
|
return resolved;
|
|
}
|
|
|
|
/** Resolve all continues of this statement. */
|
|
boolean resolveContinues(JCTree tree) {
|
|
return resolveJump(tree, new ListBuffer<P>(), JumpKind.CONTINUE);
|
|
}
|
|
|
|
/** Resolve all breaks of this statement. */
|
|
boolean resolveBreaks(JCTree tree, ListBuffer<P> oldPendingExits) {
|
|
return resolveJump(tree, oldPendingExits, JumpKind.BREAK);
|
|
}
|
|
|
|
@Override
|
|
public void scan(JCTree tree) {
|
|
if (tree != null && (
|
|
tree.type == null ||
|
|
tree.type != Type.stuckType)) {
|
|
super.scan(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> {
|
|
|
|
/** 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<>();
|
|
lint = lint.augment(tree.sym);
|
|
|
|
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);
|
|
|
|
Assert.check(pendingExits.isEmpty());
|
|
|
|
try {
|
|
alive = true;
|
|
scanStat(tree.body);
|
|
|
|
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<>();
|
|
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);
|
|
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<>();
|
|
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<>();
|
|
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<>();
|
|
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<>();
|
|
scanStat(tree.body);
|
|
alive |= resolveContinues(tree);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
alive = true;
|
|
}
|
|
|
|
public void visitLabelled(JCLabeledStatement tree) {
|
|
ListBuffer<PendingExit> prevPendingExits = pendingExits;
|
|
pendingExits = new ListBuffer<>();
|
|
scanStat(tree.body);
|
|
alive |= resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitSwitch(JCSwitch tree) {
|
|
ListBuffer<PendingExit> prevPendingExits = pendingExits;
|
|
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;
|
|
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<>();
|
|
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(new PendingExit(tree));
|
|
}
|
|
|
|
public void visitContinue(JCContinue tree) {
|
|
recordExit(new PendingExit(tree));
|
|
}
|
|
|
|
public void visitReturn(JCReturn tree) {
|
|
scan(tree.expr);
|
|
recordExit(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);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void visitLambda(JCLambda tree) {
|
|
if (tree.type != null &&
|
|
tree.type.isErroneous()) {
|
|
return;
|
|
}
|
|
|
|
ListBuffer<PendingExit> prevPending = pendingExits;
|
|
boolean prevAlive = alive;
|
|
try {
|
|
pendingExits = new ListBuffer<>();
|
|
alive = true;
|
|
scanStat(tree.body);
|
|
tree.canCompleteNormally = alive;
|
|
}
|
|
finally {
|
|
pendingExits = prevPending;
|
|
alive = prevAlive;
|
|
}
|
|
}
|
|
|
|
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<>();
|
|
alive = true;
|
|
scan(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.
|
|
*/
|
|
HashMap<Symbol, List<Type>> preciseRethrowTypes;
|
|
|
|
/** The current class being defined.
|
|
*/
|
|
JCClassDecl classDef;
|
|
|
|
/** The list of possibly thrown declarable exceptions.
|
|
*/
|
|
List<Type> thrown;
|
|
|
|
/** The list of exceptions that are either caught or declared to be
|
|
* thrown.
|
|
*/
|
|
List<Type> caught;
|
|
|
|
class FlowPendingExit extends BaseAnalyzer.PendingExit {
|
|
|
|
Type thrown;
|
|
|
|
FlowPendingExit(JCTree tree, Type thrown) {
|
|
super(tree);
|
|
this.thrown = thrown;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
void markDead() {
|
|
//do nothing
|
|
}
|
|
|
|
/*-------------------- Exceptions ----------------------*/
|
|
|
|
/** Complain that pending exceptions are not caught.
|
|
*/
|
|
void errorUncaught() {
|
|
for (FlowPendingExit exit = pendingExits.next();
|
|
exit != null;
|
|
exit = pendingExits.next()) {
|
|
if (classDef != null &&
|
|
classDef.pos == exit.tree.pos) {
|
|
log.error(exit.tree.pos(),
|
|
"unreported.exception.default.constructor",
|
|
exit.thrown);
|
|
} else if (exit.tree.hasTag(VARDEF) &&
|
|
((JCVariableDecl)exit.tree).sym.isResourceVariable()) {
|
|
log.error(exit.tree.pos(),
|
|
"unreported.exception.implicit.close",
|
|
exit.thrown,
|
|
((JCVariableDecl)exit.tree).sym.name);
|
|
} else {
|
|
log.error(exit.tree.pos(),
|
|
"unreported.exception.need.to.catch.or.throw",
|
|
exit.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));
|
|
}
|
|
thrown = chk.incl(exc, thrown);
|
|
}
|
|
}
|
|
|
|
/*************************************************************************
|
|
* Visitor methods for statements and definitions
|
|
*************************************************************************/
|
|
|
|
/* ------------ 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;
|
|
ListBuffer<FlowPendingExit> pendingExitsPrev = pendingExits;
|
|
Lint lintPrev = lint;
|
|
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
if (tree.name != names.empty) {
|
|
caught = List.nil();
|
|
}
|
|
classDef = tree;
|
|
thrown = List.nil();
|
|
lint = lint.augment(tree.sym);
|
|
|
|
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) {
|
|
scan(l.head);
|
|
errorUncaught();
|
|
}
|
|
}
|
|
|
|
// add intersection of all thrown clauses of initial constructors
|
|
// to set of caught exceptions, unless class is anonymous.
|
|
if (tree.name != names.empty) {
|
|
boolean firstConstructor = true;
|
|
for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
|
|
if (TreeInfo.isInitialConstructor(l.head)) {
|
|
List<Type> mthrown =
|
|
((JCMethodDecl) l.head).sym.type.getThrownTypes();
|
|
if (firstConstructor) {
|
|
caught = mthrown;
|
|
firstConstructor = false;
|
|
} else {
|
|
caught = chk.intersect(mthrown, caught);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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) {
|
|
scan(l.head);
|
|
errorUncaught();
|
|
}
|
|
}
|
|
|
|
// in an anonymous class, add the set of thrown exceptions to
|
|
// the throws clause of the synthetic constructor and propagate
|
|
// outwards.
|
|
// Changing the throws clause on the fly is okay here because
|
|
// the anonymous constructor can't be invoked anywhere else,
|
|
// and its type hasn't been cached.
|
|
if (tree.name == names.empty) {
|
|
for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
|
|
if (TreeInfo.isInitialConstructor(l.head)) {
|
|
JCMethodDecl mdef = (JCMethodDecl)l.head;
|
|
mdef.thrown = make.Types(thrown);
|
|
mdef.sym.type = types.createMethodTypeWithThrown(mdef.sym.type, thrown);
|
|
}
|
|
}
|
|
thrownPrev = chk.union(thrown, thrownPrev);
|
|
}
|
|
|
|
// process all the methods
|
|
for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
|
|
if (l.head.hasTag(METHODDEF)) {
|
|
scan(l.head);
|
|
errorUncaught();
|
|
}
|
|
}
|
|
|
|
thrown = thrownPrev;
|
|
} finally {
|
|
pendingExits = pendingExitsPrev;
|
|
caught = caughtPrev;
|
|
classDef = classDefPrev;
|
|
lint = lintPrev;
|
|
}
|
|
}
|
|
|
|
public void visitMethodDef(JCMethodDecl tree) {
|
|
if (tree.body == null) return;
|
|
|
|
List<Type> caughtPrev = caught;
|
|
List<Type> mthrown = tree.sym.type.getThrownTypes();
|
|
Lint lintPrev = lint;
|
|
|
|
lint = lint.augment(tree.sym);
|
|
|
|
Assert.check(pendingExits.isEmpty());
|
|
|
|
try {
|
|
for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
|
|
JCVariableDecl def = l.head;
|
|
scan(def);
|
|
}
|
|
if (TreeInfo.isInitialConstructor(tree))
|
|
caught = chk.union(caught, mthrown);
|
|
else if ((tree.sym.flags() & (BLOCK | STATIC)) != BLOCK)
|
|
caught = mthrown;
|
|
// else we are in an instance initializer block;
|
|
// leave caught unchanged.
|
|
|
|
scan(tree.body);
|
|
|
|
List<FlowPendingExit> exits = pendingExits.toList();
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
while (exits.nonEmpty()) {
|
|
FlowPendingExit exit = exits.head;
|
|
exits = exits.tail;
|
|
if (exit.thrown == null) {
|
|
Assert.check(exit.tree.hasTag(RETURN));
|
|
} else {
|
|
// uncaught throws will be reported later
|
|
pendingExits.append(exit);
|
|
}
|
|
}
|
|
} finally {
|
|
caught = caughtPrev;
|
|
lint = lintPrev;
|
|
}
|
|
}
|
|
|
|
public void visitVarDef(JCVariableDecl tree) {
|
|
if (tree.init != null) {
|
|
Lint lintPrev = lint;
|
|
lint = lint.augment(tree.sym);
|
|
try{
|
|
scan(tree.init);
|
|
} finally {
|
|
lint = lintPrev;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void visitBlock(JCBlock tree) {
|
|
scan(tree.stats);
|
|
}
|
|
|
|
public void visitDoLoop(JCDoWhileLoop tree) {
|
|
ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
scan(tree.body);
|
|
resolveContinues(tree);
|
|
scan(tree.cond);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitWhileLoop(JCWhileLoop tree) {
|
|
ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
scan(tree.cond);
|
|
scan(tree.body);
|
|
resolveContinues(tree);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitForLoop(JCForLoop tree) {
|
|
ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
|
|
scan(tree.init);
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
if (tree.cond != null) {
|
|
scan(tree.cond);
|
|
}
|
|
scan(tree.body);
|
|
resolveContinues(tree);
|
|
scan(tree.step);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitForeachLoop(JCEnhancedForLoop tree) {
|
|
visitVarDef(tree.var);
|
|
ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
|
|
scan(tree.expr);
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
scan(tree.body);
|
|
resolveContinues(tree);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitLabelled(JCLabeledStatement tree) {
|
|
ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
scan(tree.body);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitSwitch(JCSwitch tree) {
|
|
ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
scan(tree.selector);
|
|
for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
|
|
JCCase c = l.head;
|
|
if (c.pat != null) {
|
|
scan(c.pat);
|
|
}
|
|
scan(c.stats);
|
|
}
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
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) {
|
|
List<JCExpression> subClauses = TreeInfo.isMultiCatch(l.head) ?
|
|
((JCTypeUnion)l.head.param.vartype).alternatives :
|
|
List.of(l.head.param.vartype);
|
|
for (JCExpression ct : subClauses) {
|
|
caught = chk.incl(ct.type, caught);
|
|
}
|
|
}
|
|
|
|
ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
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
|
|
}
|
|
}
|
|
for (JCTree resource : tree.resources) {
|
|
List<Type> closeableSupertypes = resource.type.isCompound() ?
|
|
types.interfaces(resource.type).prepend(types.supertype(resource.type)) :
|
|
List.of(resource.type);
|
|
for (Type sup : closeableSupertypes) {
|
|
if (types.asSuper(sup, syms.autoCloseableType.tsym) != null) {
|
|
Symbol closeMethod = rs.resolveQualifiedMethod(tree,
|
|
attrEnv,
|
|
sup,
|
|
names.close,
|
|
List.<Type>nil(),
|
|
List.<Type>nil());
|
|
Type mt = types.memberType(resource.type, closeMethod);
|
|
if (closeMethod.kind == MTH) {
|
|
for (Type t : mt.getThrownTypes()) {
|
|
markThrown(resource, t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
scan(tree.body);
|
|
List<Type> thrownInTry = allowImprovedCatchAnalysis ?
|
|
chk.union(thrown, List.of(syms.runtimeExceptionType, syms.errorType)) :
|
|
thrown;
|
|
thrown = thrownPrev;
|
|
caught = caughtPrev;
|
|
|
|
List<Type> caughtInTry = List.nil();
|
|
for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
|
|
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();
|
|
List<Type> rethrownTypes = chk.diff(thrownInTry, caughtInTry);
|
|
for (JCExpression ct : subClauses) {
|
|
Type exc = ct.type;
|
|
if (exc != syms.unknownType) {
|
|
ctypes = ctypes.append(exc);
|
|
if (types.isSameType(exc, syms.objectType))
|
|
continue;
|
|
checkCaughtType(l.head.pos(), exc, thrownInTry, caughtInTry);
|
|
caughtInTry = chk.incl(exc, caughtInTry);
|
|
}
|
|
}
|
|
scan(param);
|
|
preciseRethrowTypes.put(param.sym, chk.intersect(ctypes, rethrownTypes));
|
|
scan(l.head.body);
|
|
preciseRethrowTypes.remove(param.sym);
|
|
}
|
|
if (tree.finalizer != null) {
|
|
List<Type> savedThrown = thrown;
|
|
thrown = List.nil();
|
|
ListBuffer<FlowPendingExit> exits = pendingExits;
|
|
pendingExits = prevPendingExits;
|
|
scan(tree.finalizer);
|
|
if (!tree.finallyCanCompleteNormally) {
|
|
// discard exits and exceptions from try and finally
|
|
thrown = chk.union(thrown, thrownPrev);
|
|
} 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());
|
|
}
|
|
}
|
|
} else {
|
|
thrown = chk.union(thrown, chk.diff(thrownInTry, caughtInTry));
|
|
ListBuffer<FlowPendingExit> exits = pendingExits;
|
|
pendingExits = prevPendingExits;
|
|
while (exits.nonEmpty()) pendingExits.append(exits.next());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void visitIf(JCIf tree) {
|
|
scan(tree.cond);
|
|
scan(tree.thenpart);
|
|
if (tree.elsepart != null) {
|
|
scan(tree.elsepart);
|
|
}
|
|
}
|
|
|
|
void checkCaughtType(DiagnosticPosition pos, Type exc, List<Type> thrownInTry, List<Type> caughtInTry) {
|
|
if (chk.subset(exc, caughtInTry)) {
|
|
log.error(pos, "except.already.caught", exc);
|
|
} else if (!chk.isUnchecked(pos, exc) &&
|
|
!isExceptionOrThrowable(exc) &&
|
|
!chk.intersects(exc, thrownInTry)) {
|
|
log.error(pos, "except.never.thrown.in.try", exc);
|
|
} else if (allowImprovedCatchAnalysis) {
|
|
List<Type> catchableThrownTypes = chk.intersect(List.of(exc), thrownInTry);
|
|
// 'catchableThrownTypes' cannnot possibly be empty - if 'exc' was an
|
|
// unchecked exception, the result list would not be empty, as the augmented
|
|
// thrown set includes { RuntimeException, Error }; if 'exc' was a checked
|
|
// exception, that would have been covered in the branch above
|
|
if (chk.diff(catchableThrownTypes, caughtInTry).isEmpty() &&
|
|
!isExceptionOrThrowable(exc)) {
|
|
String key = catchableThrownTypes.length() == 1 ?
|
|
"unreachable.catch" :
|
|
"unreachable.catch.1";
|
|
log.warning(pos, key, catchableThrownTypes);
|
|
}
|
|
}
|
|
}
|
|
//where
|
|
private boolean isExceptionOrThrowable(Type exc) {
|
|
return exc.tsym == syms.throwableType.tsym ||
|
|
exc.tsym == syms.exceptionType.tsym;
|
|
}
|
|
|
|
public void visitBreak(JCBreak tree) {
|
|
recordExit(new FlowPendingExit(tree, null));
|
|
}
|
|
|
|
public void visitContinue(JCContinue tree) {
|
|
recordExit(new FlowPendingExit(tree, null));
|
|
}
|
|
|
|
public void visitReturn(JCReturn tree) {
|
|
scan(tree.expr);
|
|
recordExit(new FlowPendingExit(tree, null));
|
|
}
|
|
|
|
public void visitThrow(JCThrow tree) {
|
|
scan(tree.expr);
|
|
Symbol sym = TreeInfo.symbol(tree.expr);
|
|
if (sym != null &&
|
|
sym.kind == VAR &&
|
|
(sym.flags() & (FINAL | EFFECTIVELY_FINAL)) != 0 &&
|
|
preciseRethrowTypes.get(sym) != null &&
|
|
allowImprovedRethrowAnalysis) {
|
|
for (Type t : preciseRethrowTypes.get(sym)) {
|
|
markThrown(tree, t);
|
|
}
|
|
}
|
|
else {
|
|
markThrown(tree, tree.expr.type);
|
|
}
|
|
markDead();
|
|
}
|
|
|
|
public void visitApply(JCMethodInvocation tree) {
|
|
scan(tree.meth);
|
|
scan(tree.args);
|
|
for (List<Type> l = tree.meth.type.getThrownTypes(); l.nonEmpty(); l = l.tail)
|
|
markThrown(tree, l.head);
|
|
}
|
|
|
|
public void visitNewClass(JCNewClass tree) {
|
|
scan(tree.encl);
|
|
scan(tree.args);
|
|
// scan(tree.def);
|
|
for (List<Type> l = tree.constructorType.getThrownTypes();
|
|
l.nonEmpty();
|
|
l = l.tail) {
|
|
markThrown(tree, l.head);
|
|
}
|
|
List<Type> caughtPrev = caught;
|
|
try {
|
|
// If the new class expression defines an anonymous class,
|
|
// analysis of the anonymous constructor may encounter thrown
|
|
// types which are unsubstituted type variables.
|
|
// However, since the constructor's actual thrown types have
|
|
// already been marked as thrown, it is safe to simply include
|
|
// each of the constructor's formal thrown types in the set of
|
|
// 'caught/declared to be thrown' types, for the duration of
|
|
// the class def analysis.
|
|
if (tree.def != null)
|
|
for (List<Type> l = tree.constructor.type.getThrownTypes();
|
|
l.nonEmpty();
|
|
l = l.tail) {
|
|
caught = chk.incl(l.head, caught);
|
|
}
|
|
scan(tree.def);
|
|
}
|
|
finally {
|
|
caught = caughtPrev;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void visitLambda(JCLambda tree) {
|
|
if (tree.type != null &&
|
|
tree.type.isErroneous()) {
|
|
return;
|
|
}
|
|
List<Type> prevCaught = caught;
|
|
List<Type> prevThrown = thrown;
|
|
ListBuffer<FlowPendingExit> prevPending = pendingExits;
|
|
try {
|
|
pendingExits = new ListBuffer<>();
|
|
caught = tree.getDescriptorType(types).getThrownTypes();
|
|
thrown = List.nil();
|
|
scan(tree.body);
|
|
List<FlowPendingExit> exits = pendingExits.toList();
|
|
pendingExits = new ListBuffer<FlowPendingExit>();
|
|
while (exits.nonEmpty()) {
|
|
FlowPendingExit exit = exits.head;
|
|
exits = exits.tail;
|
|
if (exit.thrown == null) {
|
|
Assert.check(exit.tree.hasTag(RETURN));
|
|
} else {
|
|
// uncaught throws will be reported later
|
|
pendingExits.append(exit);
|
|
}
|
|
}
|
|
|
|
errorUncaught();
|
|
} finally {
|
|
pendingExits = prevPending;
|
|
caught = prevCaught;
|
|
thrown = prevThrown;
|
|
}
|
|
}
|
|
|
|
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<FlowPendingExit>();
|
|
preciseRethrowTypes = new HashMap<Symbol, List<Type>>();
|
|
this.thrown = this.caught = null;
|
|
this.classDef = null;
|
|
scan(tree);
|
|
} finally {
|
|
pendingExits = null;
|
|
Flow.this.make = null;
|
|
this.thrown = this.caught = null;
|
|
this.classDef = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Specialized pass that performs inference of thrown types for lambdas.
|
|
*/
|
|
class LambdaFlowAnalyzer extends FlowAnalyzer {
|
|
List<Type> inferredThrownTypes;
|
|
boolean inLambda;
|
|
@Override
|
|
public void visitLambda(JCLambda tree) {
|
|
if ((tree.type != null &&
|
|
tree.type.isErroneous()) || inLambda) {
|
|
return;
|
|
}
|
|
List<Type> prevCaught = caught;
|
|
List<Type> prevThrown = thrown;
|
|
ListBuffer<FlowPendingExit> prevPending = pendingExits;
|
|
inLambda = true;
|
|
try {
|
|
pendingExits = new ListBuffer<>();
|
|
caught = List.of(syms.throwableType);
|
|
thrown = List.nil();
|
|
scan(tree.body);
|
|
inferredThrownTypes = thrown;
|
|
} finally {
|
|
pendingExits = prevPending;
|
|
caught = prevCaught;
|
|
thrown = prevThrown;
|
|
inLambda = false;
|
|
}
|
|
}
|
|
@Override
|
|
public void visitClassDef(JCClassDecl tree) {
|
|
//skip
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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. This pass is also used to mark
|
|
* effectively-final local variables/parameters.
|
|
*/
|
|
|
|
public class AssignAnalyzer extends BaseAnalyzer<AssignAnalyzer.AssignPendingExit> {
|
|
/** The set of definitely assigned variables.
|
|
*/
|
|
final Bits inits;
|
|
|
|
/** The set of definitely unassigned variables.
|
|
*/
|
|
final Bits uninits;
|
|
|
|
/** 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
|
|
* correct set of variables which are definitely unassigned
|
|
* anywhere in current try block, intersect uninitsTry and
|
|
* uninits.
|
|
*/
|
|
final Bits uninitsTry;
|
|
|
|
/** When analyzing a condition, inits and uninits are null.
|
|
* Instead we have:
|
|
*/
|
|
final Bits initsWhenTrue;
|
|
final Bits initsWhenFalse;
|
|
final Bits uninitsWhenTrue;
|
|
final Bits uninitsWhenFalse;
|
|
|
|
/** A mapping from addresses to variable symbols.
|
|
*/
|
|
protected JCVariableDecl[] vardecls;
|
|
|
|
/** The current class being defined.
|
|
*/
|
|
JCClassDecl classDef;
|
|
|
|
/** The first variable sequence number in this class definition.
|
|
*/
|
|
int firstadr;
|
|
|
|
/** The next available variable sequence number.
|
|
*/
|
|
protected int nextadr;
|
|
|
|
/** The first variable sequence number in a block that can return.
|
|
*/
|
|
protected int returnadr;
|
|
|
|
/** The list of unreferenced automatic resources.
|
|
*/
|
|
Scope unrefdResources;
|
|
|
|
/** Modified when processing a loop body the second time for DU analysis. */
|
|
FlowKind flowKind = FlowKind.NORMAL;
|
|
|
|
/** The starting position of the analyzed tree */
|
|
int startPos;
|
|
|
|
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 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
|
|
void resolveJump() {
|
|
inits.andSet(exit_inits);
|
|
uninits.andSet(exit_uninits);
|
|
}
|
|
}
|
|
|
|
public AssignAnalyzer() {
|
|
this.inits = new Bits();
|
|
uninits = new Bits();
|
|
uninitsTry = new Bits();
|
|
initsWhenTrue = new Bits(true);
|
|
initsWhenFalse = new Bits(true);
|
|
uninitsWhenTrue = new Bits(true);
|
|
uninitsWhenFalse = new Bits(true);
|
|
}
|
|
|
|
private boolean isInitialConstructor = false;
|
|
|
|
@Override
|
|
void markDead() {
|
|
if (!isInitialConstructor) {
|
|
inits.inclRange(returnadr, nextadr);
|
|
} else {
|
|
for (int address = returnadr; address < nextadr; address++) {
|
|
if (!(isFinalUninitializedStaticField(vardecls[address].sym))) {
|
|
inits.incl(address);
|
|
}
|
|
}
|
|
}
|
|
uninits.inclRange(returnadr, nextadr);
|
|
}
|
|
|
|
/*-------------- Processing variables ----------------------*/
|
|
|
|
/** Do we need to track init/uninit state of this symbol?
|
|
* I.e. is symbol either a local or a blank final variable?
|
|
*/
|
|
protected boolean trackable(VarSymbol sym) {
|
|
return
|
|
sym.pos >= startPos &&
|
|
((sym.owner.kind == MTH ||
|
|
isFinalUninitializedField(sym)));
|
|
}
|
|
|
|
boolean isFinalUninitializedField(VarSymbol sym) {
|
|
return sym.owner.kind == TYP &&
|
|
((sym.flags() & (FINAL | HASINIT | PARAMETER)) == FINAL &&
|
|
classDef.sym.isEnclosedBy((ClassSymbol)sym.owner));
|
|
}
|
|
|
|
boolean isFinalUninitializedStaticField(VarSymbol sym) {
|
|
return isFinalUninitializedField(sym) && sym.isStatic();
|
|
}
|
|
|
|
/** 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.
|
|
*/
|
|
void newVar(JCVariableDecl varDecl) {
|
|
VarSymbol sym = varDecl.sym;
|
|
vardecls = ArrayUtils.ensureCapacity(vardecls, nextadr);
|
|
if ((sym.flags() & FINAL) == 0) {
|
|
sym.flags_field |= EFFECTIVELY_FINAL;
|
|
}
|
|
sym.adr = nextadr;
|
|
vardecls[nextadr] = varDecl;
|
|
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() & 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);
|
|
}
|
|
}
|
|
//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.
|
|
*/
|
|
void letInit(JCTree tree) {
|
|
tree = TreeInfo.skipParens(tree);
|
|
if (tree.hasTag(IDENT) || tree.hasTag(SELECT)) {
|
|
Symbol sym = TreeInfo.symbol(tree);
|
|
if (sym.kind == VAR) {
|
|
letInit(tree.pos(), (VarSymbol)sym);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Check that trackable variable is initialized.
|
|
*/
|
|
void checkInit(DiagnosticPosition pos, VarSymbol sym) {
|
|
checkInit(pos, sym, "var.might.not.have.been.initialized");
|
|
}
|
|
|
|
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) {
|
|
b.reset();
|
|
}
|
|
}
|
|
|
|
/** Split (duplicate) inits/uninits into WhenTrue/WhenFalse sets
|
|
*/
|
|
void split(boolean setToNull) {
|
|
initsWhenFalse.assign(inits);
|
|
uninitsWhenFalse.assign(uninits);
|
|
initsWhenTrue.assign(inits);
|
|
uninitsWhenTrue.assign(uninits);
|
|
if (setToNull) {
|
|
resetBits(inits, uninits);
|
|
}
|
|
}
|
|
|
|
/** Merge (intersect) inits/uninits from WhenTrue/WhenFalse sets.
|
|
*/
|
|
protected void merge() {
|
|
inits.assign(initsWhenFalse.andSet(initsWhenTrue));
|
|
uninits.assign(uninitsWhenFalse.andSet(uninitsWhenTrue));
|
|
}
|
|
|
|
/* ************************************************************************
|
|
* Visitor methods for statements and definitions
|
|
*************************************************************************/
|
|
|
|
/** Analyze an expression. Make sure to set (un)inits rather than
|
|
* (un)initsWhenTrue(WhenFalse) on exit.
|
|
*/
|
|
void scanExpr(JCTree tree) {
|
|
if (tree != null) {
|
|
scan(tree);
|
|
if (inits.isReset()) {
|
|
merge();
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Analyze a list of expressions.
|
|
*/
|
|
void scanExprs(List<? extends JCExpression> trees) {
|
|
if (trees != null)
|
|
for (List<? extends JCExpression> l = trees; l.nonEmpty(); l = l.tail)
|
|
scanExpr(l.head);
|
|
}
|
|
|
|
/** 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();
|
|
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();
|
|
initsWhenFalse.assign(inits);
|
|
initsWhenFalse.inclRange(firstadr, nextadr);
|
|
uninitsWhenFalse.assign(uninits);
|
|
uninitsWhenFalse.inclRange(firstadr, nextadr);
|
|
initsWhenTrue.assign(inits);
|
|
uninitsWhenTrue.assign(uninits);
|
|
} else {
|
|
scan(tree);
|
|
if (!inits.isReset())
|
|
split(tree.type != syms.unknownType);
|
|
}
|
|
if (tree.type != syms.unknownType) {
|
|
resetBits(inits, uninits);
|
|
}
|
|
}
|
|
|
|
/* ------------ Visitor methods for various sorts of trees -------------*/
|
|
|
|
public void visitClassDef(JCClassDecl tree) {
|
|
if (tree.sym == null) {
|
|
return;
|
|
}
|
|
|
|
Lint lintPrev = lint;
|
|
lint = lint.augment(tree.sym);
|
|
try {
|
|
if (tree.sym == null) {
|
|
return;
|
|
}
|
|
|
|
JCClassDecl classDefPrev = classDef;
|
|
int firstadrPrev = firstadr;
|
|
int nextadrPrev = nextadr;
|
|
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
|
|
for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
|
|
if (!l.head.hasTag(METHODDEF) &&
|
|
(TreeInfo.flags(l.head) & STATIC) != 0) {
|
|
scan(l.head);
|
|
}
|
|
}
|
|
|
|
// define all the instance 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 instance initializers
|
|
for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
|
|
if (!l.head.hasTag(METHODDEF) &&
|
|
(TreeInfo.flags(l.head) & STATIC) == 0) {
|
|
scan(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;
|
|
nextadr = nextadrPrev;
|
|
firstadr = firstadrPrev;
|
|
classDef = classDefPrev;
|
|
}
|
|
} finally {
|
|
lint = lintPrev;
|
|
}
|
|
}
|
|
|
|
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 {
|
|
if (tree.body == null) {
|
|
return;
|
|
}
|
|
/* Ignore synthetic methods, except for translated lambda methods.
|
|
*/
|
|
if ((tree.sym.flags() & (SYNTHETIC | LAMBDA_METHOD)) == SYNTHETIC) {
|
|
return;
|
|
}
|
|
|
|
final Bits initsPrev = new Bits(inits);
|
|
final Bits uninitsPrev = new Bits(uninits);
|
|
int nextadrPrev = nextadr;
|
|
int firstadrPrev = firstadr;
|
|
int returnadrPrev = returnadr;
|
|
|
|
Assert.check(pendingExits.isEmpty());
|
|
boolean lastInitialConstructor = isInitialConstructor;
|
|
try {
|
|
isInitialConstructor = TreeInfo.isInitialConstructor(tree);
|
|
|
|
if (!isInitialConstructor) {
|
|
firstadr = nextadr;
|
|
}
|
|
for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
|
|
JCVariableDecl def = l.head;
|
|
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
|
|
* synthetic or mandated variables, ignore them.
|
|
*/
|
|
initParam(def);
|
|
}
|
|
// 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();
|
|
pendingExits = new ListBuffer<>();
|
|
while (exits.nonEmpty()) {
|
|
AssignPendingExit exit = exits.head;
|
|
exits = exits.tail;
|
|
Assert.check(exit.tree.hasTag(RETURN), exit.tree);
|
|
if (isInitialConstructor) {
|
|
inits.assign(exit.exit_inits);
|
|
for (int i = firstadr; i < nextadr; i++) {
|
|
checkInit(exit.tree.pos(), vardecls[i].sym);
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
inits.assign(initsPrev);
|
|
uninits.assign(uninitsPrev);
|
|
nextadr = nextadrPrev;
|
|
firstadr = firstadrPrev;
|
|
returnadr = returnadrPrev;
|
|
isInitialConstructor = lastInitialConstructor;
|
|
}
|
|
} finally {
|
|
lint = lintPrev;
|
|
}
|
|
}
|
|
|
|
protected void initParam(JCVariableDecl def) {
|
|
inits.incl(def.sym.adr);
|
|
uninits.excl(def.sym.adr);
|
|
}
|
|
|
|
public void visitVarDef(JCVariableDecl tree) {
|
|
Lint lintPrev = lint;
|
|
lint = lint.augment(tree.sym);
|
|
try{
|
|
boolean track = trackable(tree.sym);
|
|
if (track && tree.sym.owner.kind == MTH) {
|
|
newVar(tree);
|
|
}
|
|
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;
|
|
}
|
|
|
|
public void visitDoLoop(JCDoWhileLoop tree) {
|
|
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 = 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 (log.nerrors != prevErrors ||
|
|
flowKind.isFinal() ||
|
|
new Bits(uninitsEntry).diffSet(uninitsWhenTrue).nextBit(firstadr)==-1)
|
|
break;
|
|
inits.assign(initsWhenTrue);
|
|
uninits.assign(uninitsEntry.andSet(uninitsWhenTrue));
|
|
flowKind = FlowKind.SPECULATIVE_LOOP;
|
|
} while (true);
|
|
flowKind = prevFlowKind;
|
|
inits.assign(initsSkip);
|
|
uninits.assign(uninitsSkip);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitWhileLoop(JCWhileLoop tree) {
|
|
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 = log.nerrors;
|
|
final Bits uninitsEntry = new Bits(uninits);
|
|
uninitsEntry.excludeFrom(nextadr);
|
|
do {
|
|
scanCond(tree.cond);
|
|
if (!flowKind.isFinal()) {
|
|
initsSkip.assign(initsWhenFalse) ;
|
|
uninitsSkip.assign(uninitsWhenFalse);
|
|
}
|
|
inits.assign(initsWhenTrue);
|
|
uninits.assign(uninitsWhenTrue);
|
|
scan(tree.body);
|
|
resolveContinues(tree);
|
|
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
|
|
inits.assign(initsSkip);
|
|
uninits.assign(uninitsSkip);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitForLoop(JCForLoop tree) {
|
|
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<>();
|
|
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);
|
|
}
|
|
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 (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
|
|
inits.assign(initsSkip);
|
|
uninits.assign(uninitsSkip);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
nextadr = nextadrPrev;
|
|
}
|
|
|
|
public void visitForeachLoop(JCEnhancedForLoop tree) {
|
|
visitVarDef(tree.var);
|
|
|
|
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<>();
|
|
int prevErrors = log.nerrors;
|
|
do {
|
|
final Bits uninitsEntry = new Bits(uninits);
|
|
uninitsEntry.excludeFrom(nextadr);
|
|
scan(tree.body);
|
|
resolveContinues(tree);
|
|
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;
|
|
inits.assign(initsStart);
|
|
uninits.assign(uninitsStart.andSet(uninits));
|
|
resolveBreaks(tree, prevPendingExits);
|
|
nextadr = nextadrPrev;
|
|
}
|
|
|
|
public void visitLabelled(JCLabeledStatement tree) {
|
|
ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
|
|
pendingExits = new ListBuffer<>();
|
|
scan(tree.body);
|
|
resolveBreaks(tree, prevPendingExits);
|
|
}
|
|
|
|
public void visitSwitch(JCSwitch tree) {
|
|
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) {
|
|
inits.assign(initsSwitch);
|
|
uninits.assign(uninits.andSet(uninitsSwitch));
|
|
JCCase c = l.head;
|
|
if (c.pat == null) {
|
|
hasDefault = true;
|
|
} else {
|
|
scanExpr(c.pat);
|
|
}
|
|
if (hasDefault) {
|
|
inits.assign(initsSwitch);
|
|
uninits.assign(uninits.andSet(uninitsSwitch));
|
|
}
|
|
scan(c.stats);
|
|
addVars(c.stats, initsSwitch, uninitsSwitch);
|
|
if (!hasDefault) {
|
|
inits.assign(initsSwitch);
|
|
uninits.assign(uninits.andSet(uninitsSwitch));
|
|
}
|
|
// Warn about fall-through if lint switch fallthrough enabled.
|
|
}
|
|
if (!hasDefault) {
|
|
inits.andSet(initsSwitch);
|
|
}
|
|
resolveBreaks(tree, prevPendingExits);
|
|
nextadr = nextadrPrev;
|
|
}
|
|
// where
|
|
/** Add any variables defined in stats to inits and uninits. */
|
|
private void addVars(List<JCStatement> stats, final Bits inits,
|
|
final Bits uninits) {
|
|
for (;stats.nonEmpty(); stats = stats.tail) {
|
|
JCTree stat = stats.head;
|
|
if (stat.hasTag(VARDEF)) {
|
|
int adr = ((JCVariableDecl) stat).sym.adr;
|
|
inits.excl(adr);
|
|
uninits.incl(adr);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void visitTry(JCTry tree) {
|
|
ListBuffer<JCVariableDecl> resourceVarDecls = new ListBuffer<>();
|
|
final Bits uninitsTryPrev = new Bits(uninitsTry);
|
|
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) {
|
|
JCVariableDecl vdecl = (JCVariableDecl) resource;
|
|
visitVarDef(vdecl);
|
|
unrefdResources.enter(vdecl.sym);
|
|
resourceVarDecls.append(vdecl);
|
|
} else if (resource instanceof JCExpression) {
|
|
scanExpr((JCExpression) resource);
|
|
} else {
|
|
throw new AssertionError(tree); // parser error
|
|
}
|
|
}
|
|
scan(tree.body);
|
|
uninitsTry.andSet(uninits);
|
|
final Bits initsEnd = new Bits(inits);
|
|
final Bits uninitsEnd = new Bits(uninits);
|
|
int nextadrCatch = nextadr;
|
|
|
|
if (!resourceVarDecls.isEmpty() &&
|
|
lint.isEnabled(Lint.LintCategory.TRY)) {
|
|
for (JCVariableDecl resVar : resourceVarDecls) {
|
|
if (unrefdResources.includes(resVar.sym)) {
|
|
log.warning(Lint.LintCategory.TRY, resVar.pos(),
|
|
"try.resource.not.referenced", resVar.sym);
|
|
unrefdResources.remove(resVar.sym);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* The analysis of each catch should be independent.
|
|
* Each one should have the same initial values of inits and
|
|
* uninits.
|
|
*/
|
|
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;
|
|
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.
|
|
*/
|
|
initParam(param);
|
|
scan(l.head.body);
|
|
initsEnd.andSet(inits);
|
|
uninitsEnd.andSet(uninits);
|
|
nextadr = nextadrCatch;
|
|
}
|
|
if (tree.finalizer != null) {
|
|
inits.assign(initsTry);
|
|
uninits.assign(uninitsTry);
|
|
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()) {
|
|
AssignPendingExit exit = exits.next();
|
|
if (exit.exit_inits != null) {
|
|
exit.exit_inits.orSet(inits);
|
|
exit.exit_uninits.andSet(uninits);
|
|
}
|
|
pendingExits.append(exit);
|
|
}
|
|
inits.orSet(initsEnd);
|
|
}
|
|
} else {
|
|
inits.assign(initsEnd);
|
|
uninits.assign(uninitsEnd);
|
|
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);
|
|
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
|
|
// v is (un)assigned after b when true and
|
|
// v is (un)assigned after c when true
|
|
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);
|
|
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);
|
|
inits.assign(initsBeforeElse);
|
|
uninits.assign(uninitsBeforeElse);
|
|
scanExpr(tree.falsepart);
|
|
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);
|
|
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);
|
|
inits.assign(initsBeforeElse);
|
|
uninits.assign(uninitsBeforeElse);
|
|
scan(tree.elsepart);
|
|
inits.andSet(initsAfterThen);
|
|
uninits.andSet(uninitsAfterThen);
|
|
} else {
|
|
inits.andSet(initsBeforeElse);
|
|
uninits.andSet(uninitsBeforeElse);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void visitBreak(JCBreak tree) {
|
|
recordExit(new AssignPendingExit(tree, inits, uninits));
|
|
}
|
|
|
|
@Override
|
|
public void visitContinue(JCContinue tree) {
|
|
recordExit(new AssignPendingExit(tree, inits, uninits));
|
|
}
|
|
|
|
@Override
|
|
public void visitReturn(JCReturn tree) {
|
|
scanExpr(tree.expr);
|
|
recordExit(new AssignPendingExit(tree, inits, uninits));
|
|
}
|
|
|
|
public void visitThrow(JCThrow tree) {
|
|
scanExpr(tree.expr);
|
|
markDead();
|
|
}
|
|
|
|
public void visitApply(JCMethodInvocation tree) {
|
|
scanExpr(tree.meth);
|
|
scanExprs(tree.args);
|
|
}
|
|
|
|
public void visitNewClass(JCNewClass tree) {
|
|
scanExpr(tree.encl);
|
|
scanExprs(tree.args);
|
|
scan(tree.def);
|
|
}
|
|
|
|
@Override
|
|
public void visitLambda(JCLambda tree) {
|
|
final Bits prevUninits = new Bits(uninits);
|
|
final Bits prevInits = new Bits(inits);
|
|
int returnadrPrev = returnadr;
|
|
ListBuffer<AssignPendingExit> prevPending = pendingExits;
|
|
try {
|
|
returnadr = nextadr;
|
|
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);
|
|
}
|
|
if (tree.getBodyKind() == JCLambda.BodyKind.EXPRESSION) {
|
|
scanExpr(tree.body);
|
|
} else {
|
|
scan(tree.body);
|
|
}
|
|
}
|
|
finally {
|
|
returnadr = returnadrPrev;
|
|
uninits.assign(prevUninits);
|
|
inits.assign(prevInits);
|
|
pendingExits = prevPending;
|
|
}
|
|
}
|
|
|
|
public void visitNewArray(JCNewArray tree) {
|
|
scanExprs(tree.dims);
|
|
scanExprs(tree.elems);
|
|
}
|
|
|
|
public void visitAssert(JCAssert tree) {
|
|
final Bits initsExit = new Bits(inits);
|
|
final Bits uninitsExit = new Bits(uninits);
|
|
scanCond(tree.cond);
|
|
uninitsExit.andSet(uninitsWhenTrue);
|
|
if (tree.detail != null) {
|
|
inits.assign(initsWhenFalse);
|
|
uninits.assign(uninitsWhenFalse);
|
|
scanExpr(tree.detail);
|
|
}
|
|
inits.assign(initsExit);
|
|
uninits.assign(uninitsExit);
|
|
}
|
|
|
|
public void visitAssign(JCAssign tree) {
|
|
JCTree lhs = TreeInfo.skipParens(tree.lhs);
|
|
if (!isIdentOrThisDotIdent(lhs))
|
|
scanExpr(lhs);
|
|
scanExpr(tree.rhs);
|
|
letInit(lhs);
|
|
}
|
|
private boolean isIdentOrThisDotIdent(JCTree lhs) {
|
|
if (lhs.hasTag(IDENT))
|
|
return true;
|
|
if (!lhs.hasTag(SELECT))
|
|
return false;
|
|
|
|
JCFieldAccess fa = (JCFieldAccess)lhs;
|
|
return fa.selected.hasTag(IDENT) &&
|
|
((JCIdent)fa.selected).name == names._this;
|
|
}
|
|
|
|
// check fields accessed through this.<field> are definitely
|
|
// assigned before reading their value
|
|
public void visitSelect(JCFieldAccess tree) {
|
|
super.visitSelect(tree);
|
|
if (enforceThisDotInit &&
|
|
tree.selected.hasTag(IDENT) &&
|
|
((JCIdent)tree.selected).name == names._this &&
|
|
tree.sym.kind == VAR)
|
|
{
|
|
checkInit(tree.pos(), (VarSymbol)tree.sym);
|
|
}
|
|
}
|
|
|
|
public void visitAssignop(JCAssignOp tree) {
|
|
scanExpr(tree.lhs);
|
|
scanExpr(tree.rhs);
|
|
letInit(tree.lhs);
|
|
}
|
|
|
|
public void visitUnary(JCUnary tree) {
|
|
switch (tree.getTag()) {
|
|
case NOT:
|
|
scanCond(tree.arg);
|
|
final Bits t = new Bits(initsWhenFalse);
|
|
initsWhenFalse.assign(initsWhenTrue);
|
|
initsWhenTrue.assign(t);
|
|
t.assign(uninitsWhenFalse);
|
|
uninitsWhenFalse.assign(uninitsWhenTrue);
|
|
uninitsWhenTrue.assign(t);
|
|
break;
|
|
case PREINC: case POSTINC:
|
|
case PREDEC: case POSTDEC:
|
|
scanExpr(tree.arg);
|
|
letInit(tree.arg);
|
|
break;
|
|
default:
|
|
scanExpr(tree.arg);
|
|
}
|
|
}
|
|
|
|
public void visitBinary(JCBinary tree) {
|
|
switch (tree.getTag()) {
|
|
case AND:
|
|
scanCond(tree.lhs);
|
|
final Bits initsWhenFalseLeft = new Bits(initsWhenFalse);
|
|
final Bits uninitsWhenFalseLeft = new Bits(uninitsWhenFalse);
|
|
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);
|
|
inits.assign(initsWhenFalse);
|
|
uninits.assign(uninitsWhenFalse);
|
|
scanCond(tree.rhs);
|
|
initsWhenTrue.andSet(initsWhenTrueLeft);
|
|
uninitsWhenTrue.andSet(uninitsWhenTrueLeft);
|
|
break;
|
|
default:
|
|
scanExpr(tree.lhs);
|
|
scanExpr(tree.rhs);
|
|
}
|
|
}
|
|
|
|
public void visitIdent(JCIdent tree) {
|
|
if (tree.sym.kind == VAR) {
|
|
checkInit(tree.pos(), (VarSymbol)tree.sym);
|
|
referenced(tree.sym);
|
|
}
|
|
}
|
|
|
|
void referenced(Symbol sym) {
|
|
unrefdResources.remove(sym);
|
|
}
|
|
|
|
public void visitAnnotatedType(JCAnnotatedType tree) {
|
|
// annotations don't get scanned
|
|
tree.underlyingType.accept(this);
|
|
}
|
|
|
|
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<?> env) {
|
|
analyzeTree(env, env.tree);
|
|
}
|
|
|
|
public void analyzeTree(Env<?> env, JCTree tree) {
|
|
try {
|
|
startPos = tree.pos().getStartPosition();
|
|
|
|
if (vardecls == null)
|
|
vardecls = new JCVariableDecl[32];
|
|
else
|
|
for (int i=0; i<vardecls.length; i++)
|
|
vardecls[i] = null;
|
|
firstadr = 0;
|
|
nextadr = 0;
|
|
pendingExits = new ListBuffer<>();
|
|
this.classDef = null;
|
|
unrefdResources = new Scope(env.enclClass.sym);
|
|
scan(tree);
|
|
} finally {
|
|
// note that recursive invocations of this method fail hard
|
|
startPos = -1;
|
|
resetBits(inits, uninits, uninitsTry, initsWhenTrue,
|
|
initsWhenFalse, uninitsWhenTrue, uninitsWhenFalse);
|
|
if (vardecls != null) {
|
|
for (int i=0; i<vardecls.length; i++)
|
|
vardecls[i] = null;
|
|
}
|
|
firstadr = 0;
|
|
nextadr = 0;
|
|
pendingExits = 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<>();
|
|
scan(tree);
|
|
} finally {
|
|
pendingExits = null;
|
|
Flow.this.make = null;
|
|
}
|
|
}
|
|
}
|
|
}
|