jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Flow.java

-:3a2ebbad5911
+:12f99d1f23d9
 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(log, syms, lint, names).analyzeTree(env);
+new AssignAnalyzer(log, syms, lint, names, enforceThisDotInit).analyzeTree(env);
 new FlowAnalyzer().analyzeTree(env, make);
 new CaptureAnalyzer().analyzeTree(env, make);
 }
 public void analyzeLambda(Env<AttrContext> env, JCLambda that, TreeMaker make, boolean speculative) {
 //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(log, syms, lint, names).analyzeTree(env);
+new AssignAnalyzer(log, syms, lint, names, enforceThisDotInit).analyzeTree(env);
 LambdaFlowAnalyzer flowAnalyzer = new LambdaFlowAnalyzer();
 flowAnalyzer.analyzeTree(env, that, make);
 return flowAnalyzer.inferredThrownTypes;
 } finally {
 log.popDiagnosticHandler(diagHandler);
 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).
 final Symtab syms;
 protected Names names;
+final boolean enforceThisDotInit;
 public static class AbstractAssignPendingExit extends BaseAnalyzer.PendingExit {
 final Bits inits;
 final Bits uninits;
 final Bits exit_inits = new Bits(true);
 inits.andSet(exit_inits);
 uninits.andSet(exit_uninits);
 }
 }
-public AbstractAssignAnalyzer(Bits inits, Symtab syms, Names names) {
+public AbstractAssignAnalyzer(Bits inits, Symtab syms, Names names, boolean enforceThisDotInit) {
 this.inits = inits;
 uninits = new Bits();
 uninitsTry = new Bits();
 initsWhenTrue = new Bits(true);
 initsWhenFalse = new Bits(true);
 uninitsWhenTrue = new Bits(true);
 uninitsWhenFalse = new Bits(true);
 this.syms = syms;
 this.names = names;
+this.enforceThisDotInit = enforceThisDotInit;
 }
 private boolean isInitialConstructor = false;
 @Override
 uninits.assign(uninitsExit);
 }
 public void visitAssign(JCAssign tree) {
 JCTree lhs = TreeInfo.skipParens(tree.lhs);
-if (!(lhs instanceof JCIdent)) {
+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);
 public AssignPendingExit(JCTree tree, final Bits inits, final Bits uninits) {
 super(tree, inits, uninits);
 }
 }
-public AssignAnalyzer(Log log, Symtab syms, Lint lint, Names names) {
+public AssignAnalyzer(Log log, Symtab syms, Lint lint, Names names, boolean enforceThisDotInit) {
-super(new Bits(), syms, names);
+super(new Bits(), syms, names, enforceThisDotInit);
 this.log = log;
 this.lint = lint;
 }
 @Override

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Flow.java

src/share/classes/com/sun/tools/javac/comp/Flow.java