Attachment #30700 for bug #110030

Lines 684-689 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (+2 lines)
684	int LocalVariableCannotBeNull = MethodRelated + 397;	684	int LocalVariableCannotBeNull = MethodRelated + 397;
685	/** @since 3.1 */	685	/** @since 3.1 */
686	int LocalVariableCanOnlyBeNull = MethodRelated + 398;	686	int LocalVariableCanOnlyBeNull = MethodRelated + 398;
		687	/** @since 3.2 */
		688	int LocalVariableMayBeNull = MethodRelated + 399;
687		689
688	// method verifier problems	690	// method verifier problems
689	int AbstractMethodMustBeImplemented = MethodRelated + 400;	691	int AbstractMethodMustBeImplemented = MethodRelated + 400;




		// need to be careful of scenario:
		//  (x && y) && !z, if passing the left info to the right, it would be
		// swapped by the !
		FlowInfo rightInfo = leftInfo.initsWhenTrue().unconditionalCopy();
		rightInitStateIndex = currentScope.methodScope().recordInitializationStates(rightInfo);

		int previousMode = rightInfo.reachMode();

			rightInfo.setReachMode(FlowInfo.UNREACHABLE);
		}
		rightInfo = right.analyseCode(currentScope, flowContext, rightInfo);
		FlowInfo trueMergedInfo = rightInfo.initsWhenTrue().copy();
		rightInfo.setReachMode(previousMode); // reset after trueMergedInfo got extracted
		FlowInfo mergedInfo = FlowInfo.conditional(
				rightInfo.safeInitsWhenTrue(), 
				leftInfo.initsWhenFalse().unconditionalInits().mergedWith(
						rightInfo.initsWhenFalse().setReachMode(previousMode).unconditionalInits()));
		// reset after trueMergedInfo got extracted
		mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);
		return mergedInfo;
	}




		sourceStart = rec.sourceStart;
	}

public FlowInfo analyseAssignment(
		BlockScope currentScope,
		FlowContext flowContext,
		FlowInfo flowInfo,
		Assignment assignment,
		boolean compoundAssignment) {
	// unconditionalInits is applied to all existing calls -> we remove extraneous ones here
	if (assignment.expression == null) {
		return analyseCode(currentScope, flowContext, flowInfo);
	}
	return assignment
		.expression
		.analyseCode(
			currentScope,
			flowContext,
			analyseCode(currentScope, flowContext, flowInfo).unconditionalInits());
}

public FlowInfo analyseCode(
			return analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
		}
		return assignment
			.expression
			.analyseCode(
				currentScope,
				flowContext,
				analyseCode(currentScope, flowContext, flowInfo).unconditionalInits())
			.unconditionalInits();
	}

	public FlowInfo analyseCode(
		BlockScope currentScope,
		FlowContext flowContext,
		FlowInfo flowInfo) {
	receiver.checkNPE(currentScope, flowContext, flowInfo, true);
	flowInfo = receiver.analyseCode(currentScope, flowContext, flowInfo);
	return position.analyseCode(currentScope, flowContext, flowInfo);
}
	}

	public void generateAssignment(
		BlockScope currentScope,

		codeStream.arrayAtPut(this.resolvedType.id, false);
	}

public int nullStatus(FlowInfo flowInfo) {
	return FlowInfo.UNKNOWN;
}

	public StringBuffer printExpression(int indent, StringBuffer output) {

		receiver.printExpression(0, output).append('[');

Lines 54-64 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AssertStatement.java (-3 / +4 lines)
54	boolean isOptimizedTrueAssertion = cst != Constant.NotAConstant && cst.booleanValue() == true;	54	boolean isOptimizedTrueAssertion = cst != Constant.NotAConstant && cst.booleanValue() == true;
55	boolean isOptimizedFalseAssertion = cst != Constant.NotAConstant && cst.booleanValue() == false;	55	boolean isOptimizedFalseAssertion = cst != Constant.NotAConstant && cst.booleanValue() == false;
56		56
57	FlowInfo assertInfo = flowInfo.copy();	57	UnconditionalFlowInfo assertInfo = assertExpression.
		58	analyseCode(currentScope, flowContext, flowInfo.copy()).
		59	unconditionalInits();
58	if (isOptimizedTrueAssertion) {	60	if (isOptimizedTrueAssertion) {
59	assertInfo.setReachMode(FlowInfo.UNREACHABLE);	61	assertInfo.setReachMode(FlowInfo.UNREACHABLE);
60	}	62	}
61	assertInfo = assertExpression.analyseCode(currentScope, flowContext, assertInfo).unconditionalInits();
62		63
63	if (exceptionArgument != null) {	64	if (exceptionArgument != null) {
64	// only gets evaluated when escaping - results are not taken into account	65	// only gets evaluated when escaping - results are not taken into account
Lines 80-86 Link Here
80	if (isOptimizedFalseAssertion) {	81	if (isOptimizedFalseAssertion) {
81	return flowInfo; // if assertions are enabled, the following code will be unreachable	82	return flowInfo; // if assertions are enabled, the following code will be unreachable
82	} else {	83	} else {
83	return flowInfo.mergedWith(assertInfo.unconditionalInits());	84	return flowInfo.mergedWith(assertInfo);
84	}	85	}
85	}	86	}
86		87




		this.sourceEnd = sourceEnd;
	}

public FlowInfo analyseCode(
	BlockScope currentScope,
	FlowContext flowContext,
	FlowInfo flowInfo) {
	// record setting a variable: various scenarii are possible, setting an array reference, 
	// a field reference, a blank final field reference, a field of an enclosing instance or 
	// just a local variable.
	LocalVariableBinding local = this.lhs.localVariableBinding();
	int nullStatus = this.expression.nullStatus(flowInfo);
	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
		if (nullStatus == FlowInfo.NULL) {
			flowContext.recordUsingNullReference(currentScope, local, this.lhs, 
				FlowContext.CAN_ONLY_NULL, flowInfo);
		}
	}
	flowInfo = ((Reference) lhs)
		.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
		.unconditionalInits();
	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
		switch(nullStatus) {
			case FlowInfo.NULL :
				flowInfo.markAsDefinitelyNull(local);
				break;
			case FlowInfo.NON_NULL :
				flowInfo.markAsDefinitelyNonNull(local);
				break;
			default:
				flowInfo.markAsDefinitelyUnknown(local);
		}
	}		
	return flowInfo;
}

	void checkAssignmentEffect(BlockScope scope) {
		

		}
		visitor.endVisit(this, scope);
	}

public LocalVariableBinding localVariableBinding() {
	return lhs.localVariableBinding();
}
}




		this.sourceEnd = right.sourceEnd;
	}

public FlowInfo analyseCode(
		BlockScope currentScope,
		FlowContext flowContext,
		FlowInfo flowInfo) {
	left.checkNPE(currentScope, flowContext, flowInfo, false /* skip String */);
	flowInfo = left.analyseCode(currentScope, flowContext, flowInfo).
		unconditionalInits();
	right.checkNPE(currentScope, flowContext, flowInfo, false /* skip String */);
	return right.analyseCode(currentScope, flowContext, flowInfo).
		unconditionalInits();
}
	}

	public void computeConstant(BlockScope scope, int leftId, int rightId) {





		this.operator = operator ;
	}
	
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, 
		FlowInfo flowInfo) {
	// record setting a variable: various scenarii are possible, setting an array reference, 
	// a field reference, a blank final field reference, a field of an enclosing instance or 
	// just a local variable.
	lhs.checkNPE(currentScope, flowContext, flowInfo, false /* skip String */);
	return  ((Reference) lhs).analyseAssignment(currentScope, flowContext, flowInfo, this, true).unconditionalInits();
}
	
	public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
	

		codeStream.recordPositionsFrom(pc, this.sourceStart);
	}
	
public int nullStatus(FlowInfo flowInfo) {
	return FlowInfo.NON_NULL;
	// we may have complained on checkNPE, but we avoid duplicate error 
}
	
	public String operatorToString() {
		switch (operator) {




		sourceEnd = valueIfFalse.sourceEnd;
	}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
		BlockScope currentScope,
		FlowContext flowContext,
		FlowInfo flowInfo) {

		Constant cst = this.condition.optimizedBooleanConstant();
		boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;
		boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;

			boolean isValueIfFalseOptimizedTrue = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == true;
			boolean isValueIfFalseOptimizedFalse = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == false;

			UnconditionalFlowInfo trueInfoWhenTrue = trueFlowInfo.initsWhenTrue().unconditionalCopy();
			UnconditionalFlowInfo falseInfoWhenTrue = falseFlowInfo.initsWhenTrue().unconditionalCopy();
			UnconditionalFlowInfo trueInfoWhenFalse = trueFlowInfo.initsWhenFalse().unconditionalInits();
			UnconditionalFlowInfo falseInfoWhenFalse = falseFlowInfo.initsWhenFalse().unconditionalInits();
			if (isValueIfTrueOptimizedFalse) trueInfoWhenTrue.setReachMode(FlowInfo.UNREACHABLE); 

			UnconditionalFlowInfo falseInfoWhenTrue = falseFlowInfo.initsWhenTrue().copy().unconditionalInits();
			if (isValueIfFalseOptimizedFalse) falseInfoWhenTrue.setReachMode(FlowInfo.UNREACHABLE); 
			
			UnconditionalFlowInfo trueInfoWhenFalse = trueFlowInfo.initsWhenFalse().copy().unconditionalInits();
			if (isValueIfTrueOptimizedTrue) trueInfoWhenFalse.setReachMode(FlowInfo.UNREACHABLE); 

			UnconditionalFlowInfo falseInfoWhenFalse = falseFlowInfo.initsWhenFalse().copy().unconditionalInits();
			if (isValueIfFalseOptimizedTrue) falseInfoWhenFalse.setReachMode(FlowInfo.UNREACHABLE); 

			mergedInfo =

		// no implicit conversion for boolean values
		codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);
	}
	
public int nullStatus(FlowInfo flowInfo) {
	Constant cst = this.condition.optimizedBooleanConstant();
	if (cst != Constant.NotAConstant) {
		if (cst.booleanValue()) {
			return valueIfTrue.nullStatus(flowInfo);
		}
		return valueIfFalse.nullStatus(flowInfo);
	}
	int ifTrueNullStatus = valueIfTrue.nullStatus(flowInfo),
	    ifFalseNullStatus = valueIfFalse.nullStatus(flowInfo);
	if (ifTrueNullStatus == ifFalseNullStatus) {
		return ifTrueNullStatus;
	}
	return FlowInfo.UNKNOWN;
	// cannot decide which branch to take, and they disagree
}

	public Constant optimizedBooleanConstant() {


Lines 71-77 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java (-1 / +1 lines)
71	flowInfo.addInitializationsFrom(tryStatement.subRoutineInits); // collect inits	71	flowInfo.addInitializationsFrom(tryStatement.subRoutineInits); // collect inits
72	} else if (traversedContext == targetContext) {	72	} else if (traversedContext == targetContext) {
73	// only record continue info once accumulated through subroutines, and only against target context	73	// only record continue info once accumulated through subroutines, and only against target context
74	targetContext.recordContinueFrom(flowInfo);	74	targetContext.recordContinueFrom(flowContext, flowInfo);
75	break;	75	break;
76	}	76	}
77	} while ((traversedContext = traversedContext.parent) != null);	77	} while ((traversedContext = traversedContext.parent) != null);

Lines 46-51 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/DoStatement.java (-8 / +26 lines)
46	LoopingFlowContext loopingContext =	46	LoopingFlowContext loopingContext =
47	new LoopingFlowContext(	47	new LoopingFlowContext(
48	flowContext,	48	flowContext,
		49	flowInfo,
49	this,	50	this,
50	breakLabel,	51	breakLabel,
51	continueLabel,	52	continueLabel,
Lines 59-67 Link Here
59		60
60	int previousMode = flowInfo.reachMode();	61	int previousMode = flowInfo.reachMode();
61		62
62	FlowInfo actionInfo = flowInfo.copy().unconditionalInits().discardNullRelatedInitializations();	63	UnconditionalFlowInfo actionInfo = flowInfo.nullInfoLessUnconditionalCopy();
		64	// we need to collect the contribution to nulls of the coming paths through the
		65	// loop, be they falling through normally or branched to break, continue labels
		66	// or catch blocks
63	if ((action != null) && !action.isEmptyBlock()) {	67	if ((action != null) && !action.isEmptyBlock()) {
64	actionInfo = action.analyseCode(currentScope, loopingContext, actionInfo);	68	actionInfo = action.
		69	analyseCode(currentScope, loopingContext, actionInfo).
		70	unconditionalInits();
65		71
66	// code generation can be optimized when no need to continue in the loop	72	// code generation can be optimized when no need to continue in the loop
67	if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {	73	if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {
Lines 75-96 Link Here
75	*/	81	*/
76	actionInfo.setReachMode(previousMode);	82	actionInfo.setReachMode(previousMode);
77		83
78	actionInfo =	84	LoopingFlowContext condLoopContext;
		85	FlowInfo condInfo =
79	condition.analyseCode(	86	condition.analyseCode(
80	currentScope,	87	currentScope,
81	loopingContext,	88	(condLoopContext =
		89	new LoopingFlowContext(flowContext, flowInfo, this, null,
		90	null, currentScope)),
82	(action == null	91	(action == null
83	? actionInfo	92	? actionInfo
84	: (actionInfo.mergedWith(loopingContext.initsOnContinue))));	93	: (actionInfo.mergedWith(loopingContext.initsOnContinue))).copy());
85	if (!isConditionOptimizedFalse && continueLabel != null) {	94	if (!isConditionOptimizedFalse && continueLabel != null) {
86	loopingContext.complainOnDeferredChecks(currentScope, actionInfo);	95	loopingContext.complainOnDeferredFinalChecks(currentScope, condInfo);
		96	condLoopContext.complainOnDeferredFinalChecks(currentScope, condInfo);
		97	UnconditionalFlowInfo checkFlowInfo;
		98	loopingContext.complainOnDeferredNullChecks(currentScope,
		99	checkFlowInfo = actionInfo.
		100	addPotentialNullInfoFrom(
		101	condInfo.initsWhenTrue().unconditionalInits()));
		102	condLoopContext.complainOnDeferredNullChecks(currentScope,
		103	checkFlowInfo);
87	}	104	}
88		105
89	// end of loop	106	// end of loop
90	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranches(	107	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranches(
91	loopingContext.initsOnBreak,	108	loopingContext.initsOnBreak,
92	isConditionOptimizedTrue,	109	isConditionOptimizedTrue,
93	actionInfo.initsWhenFalse().addInitializationsFrom(flowInfo), // recover null inits from before condition analysis	110	condInfo.isReachable() ? flowInfo.addInitializationsFrom(condInfo.initsWhenFalse()) : condInfo,
		111	// recover null inits from before condition analysis
94	false, // never consider opt false case for DO loop, since break can always occur (47776)	112	false, // never consider opt false case for DO loop, since break can always occur (47776)
95	!isConditionTrue /do{}while(true); unreachable(); /);	113	!isConditionTrue /do{}while(true); unreachable(); /);
96	mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);	114	mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);




	public EqualExpression(Expression left, Expression right,int operator) {
		super(left,right,operator);
	}
	private void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {
		
		LocalVariableBinding local = this.left.localVariableBinding();
		if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
			checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, right.nullStatus(flowInfo), this.left);
		}
		local = this.right.localVariableBinding();
		if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
			checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, left.nullStatus(flowInfo), this.right);
		}
	}
	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, LocalVariableBinding local, int nullStatus, Expression reference) {
		switch (nullStatus) {
			case FlowInfo.NULL :
				flowContext.recordUsingNullReference(scope, local, reference, 
					FlowContext.CAN_ONLY_NULL_NON_NULL, flowInfo);
				if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
					initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set
					initsWhenFalse.markAsComparedEqualToNonNull(local); // from thereon it is set
				} else {
					initsWhenTrue.markAsComparedEqualToNonNull(local); // from thereon it is set
					initsWhenFalse.markAsComparedEqualToNull(local); // from thereon it is set
				}
				break;
			case FlowInfo.NON_NULL :
				flowContext.recordUsingNullReference(scope, local, reference, 
					FlowContext.CAN_ONLY_NULL, flowInfo);
				if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
					initsWhenTrue.markAsComparedEqualToNonNull(local); // from thereon it is set
				}
				break;
		}	
	}
	
	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
		FlowInfo result;
		if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
			if ((left.constant != Constant.NotAConstant) && (left.constant.typeID() == T_boolean)) {
				if (left.constant.booleanValue()) { //  true == anything
					//  this is equivalent to the right argument inits 
					result = right.analyseCode(currentScope, flowContext, flowInfo);
				} else { // false == anything
					//  this is equivalent to the right argument inits negated
					result = right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
				}
			} 
			else if ((right.constant != Constant.NotAConstant) && (right.constant.typeID() == T_boolean)) {
				if (right.constant.booleanValue()) { //  anything == true
					//  this is equivalent to the left argument inits 
					result = left.analyseCode(currentScope, flowContext, flowInfo);
				} else { // anything == false
					//  this is equivalent to the right argument inits negated
					result = left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
				}
			} 
			else {
				result = right.analyseCode(
					currentScope, flowContext, 
					left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).unconditionalInits();
			}
			return right.analyseCode(
				currentScope, flowContext, 
				left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).unconditionalInits();
		} else { //NOT_EQUAL :
			if ((left.constant != Constant.NotAConstant) && (left.constant.typeID() == T_boolean)) {
				if (!left.constant.booleanValue()) { //  false != anything
					//  this is equivalent to the right argument inits 
					result = right.analyseCode(currentScope, flowContext, flowInfo);
				} else { // true != anything
					//  this is equivalent to the right argument inits negated
					result = right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
				}
			}
			else if ((right.constant != Constant.NotAConstant) && (right.constant.typeID() == T_boolean)) {
				if (!right.constant.booleanValue()) { //  anything != false
					//  this is equivalent to the right argument inits 
					result = left.analyseCode(currentScope, flowContext, flowInfo);
				} else { // anything != true
					//  this is equivalent to the right argument inits negated
					result = left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
				}
			} 
			else {
				result = right.analyseCode(
					currentScope, flowContext, 
					left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).
					/* unneeded since we flatten it: asNegatedCondition(). */
					unconditionalInits();
			}
			return right.analyseCode(
				currentScope, flowContext, 
				left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).asNegatedCondition().unconditionalInits();
		}
		if (result instanceof UnconditionalFlowInfo && result.isReachable()) { // the flow info is flat
			result = FlowInfo.conditional(result, result.copy());
		}
	  checkNullComparison(currentScope, flowContext, result, result.initsWhenTrue(), result.initsWhenFalse());
	  return result;
	}
	
	public final void computeConstant(TypeBinding leftType, TypeBinding rightType) {




		}
	}	
	
/**
 * Check the local variable of this expression, if any, against potential NPEs 
 * given a flow context and an upstream flow info. If so, report the risk to
 * the context. Marks the local as checked, which affects the flow info.
 * @param scope the scope of the analysis
 * @param flowContext the current flow context
 * @param flowInfo the upstream flow info; caveat: may get modified
 * @param checkString if true, a local variable of type String is checked; else
 *        it is skipped
 */
public void checkNPE(BlockScope scope, FlowContext flowContext, 
		FlowInfo flowInfo, boolean checkString) {
	LocalVariableBinding local = this.localVariableBinding();
	if (local != null && 
			(local.type.tagBits & TagBits.IsBaseType) == 0 &&
			(checkString || local.type.id != T_JavaLangString)) {
		flowContext.recordUsingNullReference(scope, local, this, 
			FlowContext.MAY_NULL, flowInfo);
		flowInfo.markAsComparedEqualToNonNull(local); 
			// from thereon it is set
	}
}

	private MethodBinding[] getAllInheritedMethods(ReferenceBinding binding) {
		ArrayList collector = new ArrayList();

			getAllInheritedMethods0(superInterfaces[i], collector);
		}
	}
	public void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {
		// do nothing by default - see EqualExpression
	}

	public boolean checkUnsafeCast(Scope scope, TypeBinding castType, TypeBinding expressionType, TypeBinding match, boolean isNarrowing) {
		if (match == castType) {

Lines 98-104 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java (-1 / +7 lines)
98	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {	98	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
99	boolean nonStatic = !binding.isStatic();	99	boolean nonStatic = !binding.isStatic();
100	receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic);	100	receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic);
101	if (nonStatic) receiver.checkNullStatus(currentScope, flowContext, flowInfo, FlowInfo.NON_NULL);	101	if (nonStatic) {
		102	receiver.checkNPE(currentScope, flowContext, flowInfo, true);
		103	}
102		104
103	if (valueRequired \|\| currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {	105	if (valueRequired \|\| currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4) {
104	manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /read-access/);	106	manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /read-access/);
Lines 407-412 Link Here
407	}	409	}
408	}	410	}
409		411
		412	public int nullStatus(FlowInfo flowInfo) {
		413	return FlowInfo.UNKNOWN;
		414	}
		415
410	public Constant optimizedBooleanConstant() {	416	public Constant optimizedBooleanConstant() {
411	switch (this.resolvedType.id) {	417	switch (this.resolvedType.id) {
412	case T_boolean :	418	case T_boolean :




		
		// process the condition
		LoopingFlowContext condLoopContext = null;
		FlowInfo condInfo = flowInfo.nullInfoLessUnconditionalCopy();
		if (condition != null) {
			if (!isConditionTrue) {
				condInfo =
					condition.analyseCode(
						scope,
						(condLoopContext =
							new LoopingFlowContext(flowContext, flowInfo, this, null, 
								null, scope)),
						condInfo);
			}
		}

		// process the action
		LoopingFlowContext loopingContext;
		UnconditionalFlowInfo actionInfo;
		if (action == null 
			|| (action.isEmptyBlock() && currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3)) {
			if (condLoopContext != null)
				condLoopContext.complainOnDeferredFinalChecks(scope, condInfo);
			if (isConditionTrue) {
				if (condLoopContext != null) {
					condLoopContext.complainOnDeferredNullChecks(currentScope,
						condInfo);
				}
				return FlowInfo.DEAD_END;
			} else {
				if (isConditionFalse){
					continueLabel = null; // for(;false;p());
				}
				actionInfo = condInfo.initsWhenTrue().unconditionalCopy();
				loopingContext =
					new LoopingFlowContext(flowContext, flowInfo, this, 
						breakLabel, continueLabel, scope);
			}
		} 
		else {
			loopingContext =
				new LoopingFlowContext(flowContext, flowInfo, this, breakLabel, 
					continueLabel, scope);
			FlowInfo initsWhenTrue = condInfo.initsWhenTrue();
			condIfTrueInitStateIndex =
				currentScope.methodScope().recordInitializationStates(initsWhenTrue);

				if (isConditionFalse) {
					actionInfo = FlowInfo.DEAD_END;
				} else {
					actionInfo = initsWhenTrue.unconditionalCopy();
					if (isConditionOptimizedFalse){
						actionInfo.setReachMode(FlowInfo.UNREACHABLE);
					}
				}
			if (!this.action.complainIfUnreachable(actionInfo, scope, false)) {
				actionInfo = action.analyseCode(scope, loopingContext, actionInfo).
					unconditionalInits();
			}

			// code generation can be optimized when no need to continue in the loop
			if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {
				continueLabel = null;
			} 
			else {
				if (condLoopContext != null) {
					condLoopContext.complainOnDeferredFinalChecks(scope, 
							condInfo);
				}
				actionInfo = actionInfo.mergedWith(loopingContext.initsOnContinue);
				loopingContext.complainOnDeferredFinalChecks(scope, 
						actionInfo);
			}
		}
		// for increments
		FlowInfo exitBranch = flowInfo.copy();
		// recover null inits from before condition analysis
		LoopingFlowContext incrementContext = null;
		if (continueLabel != null) {
			if (increments != null) {
				incrementContext =
					new LoopingFlowContext(flowContext, flowInfo, this, null, 
						null, scope);
				FlowInfo incrementInfo = actionInfo;
				for (int i = 0, count = increments.length; i < count; i++) {
					incrementInfo = increments[i].
						analyseCode(scope, incrementContext, incrementInfo);
				}
				incrementContext.complainOnDeferredFinalChecks(scope,
						actionInfo = incrementInfo.unconditionalInits());
			}
			exitBranch.addPotentialInitializationsFrom(actionInfo).
				addInitializationsFrom(condInfo.initsWhenFalse());
		}
		else {
			exitBranch.addInitializationsFrom(condInfo.initsWhenFalse());
		}
		// nulls checks
		if (condLoopContext != null) {
			condLoopContext.complainOnDeferredNullChecks(currentScope, 
				actionInfo);
		}
		loopingContext.complainOnDeferredNullChecks(currentScope, 
			actionInfo);
		if (incrementContext != null) {
			incrementContext.complainOnDeferredNullChecks(currentScope, 
				actionInfo);
		}

		//end of loop




import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.flow.LoopingFlowContext;
import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;

		continueLabel = new Label();

		// process the element variable and collection
		this.collection.checkNPE(currentScope, flowContext, flowInfo, true);
		flowInfo = this.elementVariable.analyseCode(scope, flowContext, flowInfo);
		FlowInfo condInfo = this.collection.analyseCode(scope, flowContext, flowInfo.copy());
		condInfo = this.collection.analyseCode(scope, flowContext, condInfo);

		// element variable will be assigned when iterating
		condInfo.markAsDefinitelyAssigned(this.elementVariable.binding);

		this.postCollectionInitStateIndex = currentScope.methodScope().recordInitializationStates(condInfo);
		
		// process the action
		LoopingFlowContext loopingContext = 
			new LoopingFlowContext(flowContext, flowInfo, this, breakLabel, 
				continueLabel, scope);
		UnconditionalFlowInfo actionInfo = 
			condInfo.nullInfoLessUnconditionalCopy();
		FlowInfo exitBranch;
		if (!(action == null || (action.isEmptyBlock() 
		        	&& currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3))) {

			if (!this.action.complainIfUnreachable(actionInfo, scope, false)) {
				actionInfo = action.
					analyseCode(scope, loopingContext, actionInfo).
					unconditionalCopy();
			}

			// code generation can be optimized when no need to continue in the loop
			exitBranch = flowInfo.unconditionalCopy().
				addInitializationsFrom(condInfo.initsWhenFalse()); 
			if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {
				continueLabel = null;
			} else {
				actionInfo = actionInfo.mergedWith(loopingContext.initsOnContinue);
				loopingContext.complainOnDeferredFinalChecks(scope, actionInfo);
				exitBranch.addPotentialInitializationsFrom(actionInfo);
			}
		} else {
			exitBranch = condInfo.initsWhenFalse();

			}
		}
		//end of loop
		loopingContext.complainOnDeferredNullChecks(currentScope, actionInfo);

		FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranches(
				loopingContext.initsOnBreak, 
				false, 




		FlowInfo flowInfo) {

		// process the condition
		FlowInfo conditionFlowInfo =
			condition.analyseCode(currentScope, flowContext, flowInfo);

		Constant cst = this.condition.optimizedBooleanConstant();
		boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;
		boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;
		
		// process the THEN part
		FlowInfo thenFlowInfo = conditionFlowInfo.safeInitsWhenTrue();
		if (isConditionOptimizedFalse) {
			thenFlowInfo.setReachMode(FlowInfo.UNREACHABLE); 
		}
		FlowInfo elseFlowInfo = conditionFlowInfo.initsWhenFalse();
		if (isConditionOptimizedTrue) {
			elseFlowInfo.setReachMode(FlowInfo.UNREACHABLE); 
		}
		this.condition.checkNullComparison(currentScope, flowContext, flowInfo, thenFlowInfo, elseFlowInfo);
		if (this.thenStatement != null) {
			// Save info for code gen
			thenInitStateIndex =


		// merge THEN & ELSE initializations
		FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranches(
			thenFlowInfo, 
			isConditionOptimizedTrue, 
			elseFlowInfo, 
			isConditionOptimizedFalse,
			true /*if(true){ return; }  fake-reachable(); */);
		mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);
		return mergedInfo;
	}




		this.sourceEnd = type.sourceEnd;
	}

public FlowInfo analyseCode(
		BlockScope currentScope,
		FlowContext flowContext,
		FlowInfo flowInfo) {
	LocalVariableBinding local = this.expression.localVariableBinding();
	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
		flowContext.recordUsingNullReference(currentScope, local, 
			this.expression, FlowContext.CAN_ONLY_NULL, flowInfo);
		expression.checkNullStatus(currentScope, flowContext, flowInfo, FlowInfo.NON_NULL);
		return flowInfo;
	}
	return expression.analyseCode(currentScope, flowContext, flowInfo).
		unconditionalInits();
}

	/**
	 * Code generation for instanceOfExpression




		this.declarationEnd = sourceEnd;
	}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
		BlockScope currentScope,
		FlowContext flowContext,
		FlowInfo flowInfo) {
	// record variable initialization if any
	if (flowInfo.isReachable()) {
		bits |= IsLocalDeclarationReachable; // only set if actually reached
	}
	if (this.initialization == null) { 
		return flowInfo;
	}
	int nullStatus = this.initialization.nullStatus(flowInfo);
	flowInfo =
		this.initialization
			.analyseCode(currentScope, flowContext, flowInfo)
			.unconditionalInits();
	flowInfo.markAsDefinitelyAssigned(binding);
	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {
		flowInfo.markAsDefinitelyAssigned(binding);
		switch(nullStatus) {
			case FlowInfo.NULL :
				flowInfo.markAsDefinitelyNull(this.binding);

			case FlowInfo.NON_NULL :
				flowInfo.markAsDefinitelyNonNull(this.binding);
				break;
			default:
				flowInfo.markAsDefinitelyUnknown(this.binding);
		}
		return flowInfo;
	}
	return flowInfo;
}

	public void checkModifiers() {


Lines 42-48 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-2 / +7 lines)
42		42
43	boolean nonStatic = !binding.isStatic();	43	boolean nonStatic = !binding.isStatic();
44	flowInfo = receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();	44	flowInfo = receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();
45	if (nonStatic) receiver.checkNullStatus(currentScope, flowContext, flowInfo, FlowInfo.NON_NULL);	45	if (nonStatic) {
		46	receiver.checkNPE(currentScope, flowContext, flowInfo, true);
		47	}
46		48
47	if (arguments != null) {	49	if (arguments != null) {
48	int length = arguments.length;	50	int length = arguments.length;
Lines 53-59 Link Here
53	ReferenceBinding[] thrownExceptions;	55	ReferenceBinding[] thrownExceptions;
54	if ((thrownExceptions = binding.thrownExceptions) != NoExceptions) {	56	if ((thrownExceptions = binding.thrownExceptions) != NoExceptions) {
55	// must verify that exceptions potentially thrown by this expression are caught in the method	57	// must verify that exceptions potentially thrown by this expression are caught in the method
56	flowContext.checkExceptionHandlers(thrownExceptions, this, flowInfo, currentScope);	58	flowContext.checkExceptionHandlers(thrownExceptions, this, flowInfo.copy(), currentScope);
		59	// TODO (maxime) the copy above is needed because of a side effect into
		60	// checkExceptionHandlers; consider protecting there instead of here;
		61	// NullReferenceTest#test0510
57	}	62	}
58	manageSyntheticAccessIfNecessary(currentScope, flowInfo);	63	manageSyntheticAccessIfNecessary(currentScope, flowInfo);
59	return flowInfo;	64	return flowInfo;




	
		 // need to be careful of scenario:
		//		(x || y) || !z, if passing the left info to the right, it would be swapped by the !
		FlowInfo rightInfo = leftInfo.initsWhenFalse().unconditionalCopy();
		rightInitStateIndex =
			currentScope.methodScope().recordInitializationStates(rightInfo);


			rightInfo.setReachMode(FlowInfo.UNREACHABLE); 
		}
		rightInfo = right.analyseCode(currentScope, flowContext, rightInfo);
		FlowInfo falseMergedInfo = rightInfo.initsWhenFalse().copy();
		rightInfo.setReachMode(previousMode); // reset after falseMergedInfo got extracted

		FlowInfo mergedInfo = FlowInfo.conditional(
					// merging two true initInfos for such a negative case: if ((t && (b = t)) || f) r = b; // b may not have been initialized
					leftInfo.initsWhenTrue().unconditionalInits().mergedWith(
						rightInfo.safeInitsWhenTrue().setReachMode(previousMode).unconditionalInits()),
					rightInfo.initsWhenFalse());
		mergedInitStateIndex =
			currentScope.methodScope().recordInitializationStates(mergedInfo);
		return mergedInfo;




				} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
					localBinding.useFlag = LocalVariableBinding.FAKE_USED;
				}
				checkNPE(currentScope, flowContext, flowInfo, true);
		}
		
		if (needValue) {

				} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
					localBinding.useFlag = LocalVariableBinding.FAKE_USED;
				}
				checkNPE(currentScope, flowContext, flowInfo, true);
		}
		if (needValue) {
			manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);

		bits |= Binding.FIELD;
		return getOtherFieldBindings(scope);
	}

public void checkNPE(BlockScope scope, FlowContext flowContext, 
		FlowInfo flowInfo, boolean checkString) {
	// cannot override localVariableBinding because this would project o.m onto o when
	// analysing assignments
	if ((bits & RestrictiveFlagMASK) == Binding.LOCAL) {
		LocalVariableBinding local = (LocalVariableBinding) this.binding;
		if (local != null && 
			(local.type.tagBits & TagBits.IsBaseType) == 0 &&
			(checkString || local.type.id != T_JavaLangString)) {
			flowContext.recordUsingNullReference(scope, local, this, 
				FlowContext.MAY_NULL, flowInfo);
			flowInfo.markAsComparedEqualToNonNull(local); 
				// from thereon it is set
		}
	}
}
	/**
	 * @see org.eclipse.jdt.internal.compiler.ast.Expression#computeConversion(org.eclipse.jdt.internal.compiler.lookup.Scope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding, org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
	 */

				? type.capture(scope, this.sourceEnd)
				: type;		
	}

	public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
		if (!flowInfo.isReachable()) return;
		//If inlinable field, forget the access emulation, the code gen will directly target it

		}			
	}

public int nullStatus(FlowInfo flowInfo) {
	return FlowInfo.UNKNOWN;
}

	public Constant optimizedBooleanConstant() {

		switch (this.resolvedType.id) {




public abstract void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired);

public abstract void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired);

public int nullStatus(FlowInfo flowInfo) {

	if (this.constant != null && this.constant != Constant.NotAConstant)
		return FlowInfo.NON_NULL; // constant expression cannot be null
	
	LocalVariableBinding local = localVariableBinding();
	if (local != null) {
		if (flowInfo.isDefinitelyNull(local))
			return FlowInfo.NULL;
		if (flowInfo.isDefinitelyNonNull(local))
			return FlowInfo.NON_NULL;
	}	
	return FlowInfo.UNKNOWN;
}

}




			}					
		}
	}

public int nullStatus(FlowInfo flowInfo) {
	if (this.constant != null && this.constant != Constant.NotAConstant) {
		return FlowInfo.NON_NULL; // constant expression cannot be null
	}
	switch (bits & RestrictiveFlagMASK) {
		case Binding.FIELD : // reading a field
			return FlowInfo.UNKNOWN;
		case Binding.LOCAL : // reading a local variable
			LocalVariableBinding local = (LocalVariableBinding) this.binding;
			if (local != null) {
				if (flowInfo.isDefinitelyNull(local))
					return FlowInfo.NULL;
				if (flowInfo.isDefinitelyNonNull(local))
					return FlowInfo.NON_NULL;
				return FlowInfo.UNKNOWN;
			}
	}
	return FlowInfo.NON_NULL; 
}

	public StringBuffer printExpression(int indent, StringBuffer output){
	
		return output.append(token);

Lines 62-72 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java (-2 / +2 lines)
62	if ((caseIndex < caseCount) && (statement == cases[caseIndex])) { // statement is a case	62	if ((caseIndex < caseCount) && (statement == cases[caseIndex])) { // statement is a case
63	this.scope.enclosingCase = cases[caseIndex]; // record entering in a switch case block	63	this.scope.enclosingCase = cases[caseIndex]; // record entering in a switch case block
64	caseIndex++;	64	caseIndex++;
65	caseInits = caseInits.mergedWith(flowInfo.copy().unconditionalInits());	65	caseInits = caseInits.mergedWith(flowInfo.unconditionalInits());
66	didAlreadyComplain = false; // reset complaint	66	didAlreadyComplain = false; // reset complaint
67	} else if (statement == defaultCase) { // statement is the default case	67	} else if (statement == defaultCase) { // statement is the default case
68	this.scope.enclosingCase = defaultCase; // record entering in a switch case block	68	this.scope.enclosingCase = defaultCase; // record entering in a switch case block
69	caseInits = caseInits.mergedWith(flowInfo.copy().unconditionalInits());	69	caseInits = caseInits.mergedWith(flowInfo.unconditionalInits());
70	didAlreadyComplain = false; // reset complaint	70	didAlreadyComplain = false; // reset complaint
71	}	71	}
72	if (!statement.complainIfUnreachable(caseInits, scope, didAlreadyComplain)) {	72	if (!statement.complainIfUnreachable(caseInits, scope, didAlreadyComplain)) {




					.analyseCode(
						currentScope,
						finallyContext = new FinallyFlowContext(flowContext, finallyBlock),
						flowInfo.nullInfoLessUnconditionalCopy())
					.unconditionalInits();
			if (subInfo == FlowInfo.DEAD_END) {
				isSubRoutineEscaping = true;

			for (int i = 0; i < catchCount; i++) {
				// keep track of the inits that could potentially have led to this exception handler (for final assignments diagnosis)
				FlowInfo catchInfo =
					flowInfo.unconditionalCopy().
						addPotentialInitializationsFrom(
							handlingContext.initsOnException(
								caughtExceptionTypes[i]))
						.addPotentialInitializationsFrom(
							tryInfo.unconditionalInits())
						.addPotentialInitializationsFrom(
							handlingContext.initsOnReturn);
				// WORK this one is wrong -- too permissive for test case NullReferenceTest#test0560

				// catch var is always set
				LocalVariableBinding catchArg = catchArguments[i].binding;


		// we also need to check potential multiple assignments of final variables inside the finally block
		// need to include potential inits from returns inside the try/catch parts - 1GK2AOF
		finallyContext.complainOnDeferredChecks( //$NON-NULL-1$ null with subRoutineStartLabel, which returns
			tryInfo.isReachable() 
				? (tryInfo.addPotentialInitializationsFrom(
					insideSubContext.initsOnReturn)) //$NON-NULL-1$ null with subRoutineStartLabel, which returns
				: insideSubContext.initsOnReturn, //$NON-NULL-1$ null with subRoutineStartLabel, which returns
			currentScope);
		if (subInfo == FlowInfo.DEAD_END) {
			mergedInitStateIndex =




	 *	Common flow analysis for all types
	 *
	 */
	private void internalAnalyseCode(FlowContext flowContext, FlowInfo flowInfo) {

		if ((this.binding.isPrivate()/* || (this.binding.tagBits & (TagBits.IsAnonymousType|TagBits.IsLocalType)) == TagBits.IsLocalType*/) && !this.binding.isUsed()) {
			if (!scope.referenceCompilationUnit().compilationResult.hasSyntaxError) {


		InitializationFlowContext initializerContext = new InitializationFlowContext(null, this, initializerScope);
		InitializationFlowContext staticInitializerContext = new InitializationFlowContext(null, this, staticInitializerScope);
		FlowInfo nonStaticFieldInfo = flowInfo.unconditionalFieldLessCopy();
		FlowInfo staticFieldInfo = flowInfo.unconditionalFieldLessCopy();
		if (fields != null) {
			for (int i = 0, count = fields.length; i < count; i++) {
				FieldDeclaration field = fields[i];

			}
		}
		if (methods != null) {
			UnconditionalFlowInfo outerInfo = flowInfo.unconditionalFieldLessCopy();
			FlowInfo constructorInfo = nonStaticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo);
			for (int i = 0, count = methods.length; i < count; i++) {
				AbstractMethodDeclaration method = methods[i];




		this.bits |= operator << OperatorSHIFT; // encode operator
	}

public FlowInfo analyseCode(
		BlockScope currentScope,
		FlowContext flowContext,
		FlowInfo flowInfo) {
	this.expression.checkNPE(currentScope, flowContext, flowInfo, true);	
	if (((bits & OperatorMASK) >> OperatorSHIFT) == NOT) {
		return this.expression.
			analyseCode(currentScope, flowContext, flowInfo).
			asNegatedCondition();
	} else {
		return this.expression.
			analyseCode(currentScope, flowContext, flowInfo);
	}
}

	public Constant optimizedBooleanConstant() {
		

Lines 55-65 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java (-10 / +31 lines)
55	preCondInitStateIndex =	55	preCondInitStateIndex =
56	currentScope.methodScope().recordInitializationStates(flowInfo);	56	currentScope.methodScope().recordInitializationStates(flowInfo);
57	LoopingFlowContext condLoopContext;	57	LoopingFlowContext condLoopContext;
58	FlowInfo condInfo = flowInfo.copy().unconditionalInits().discardNullRelatedInitializations();	58	FlowInfo condInfo = flowInfo.nullInfoLessUnconditionalCopy();
		59	// we need to collect the contribution to nulls of the coming paths through the
		60	// loop, be they falling through normally or branched to break, continue labels
		61	// or catch blocks
59	condInfo = this.condition.analyseCode(	62	condInfo = this.condition.analyseCode(
60	currentScope,	63	currentScope,
61	(condLoopContext =	64	(condLoopContext =
62	new LoopingFlowContext(flowContext, this, null, null, currentScope)),	65	new LoopingFlowContext(flowContext, flowInfo, this, null,
		66	null, currentScope)),
63	condInfo);	67	condInfo);
64		68
65	LoopingFlowContext loopingContext;	69	LoopingFlowContext loopingContext;
Lines 67-83 Link Here
67	FlowInfo exitBranch;	71	FlowInfo exitBranch;
68	if (action == null	72	if (action == null
69	\|\| (action.isEmptyBlock() && currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3)) {	73	\|\| (action.isEmptyBlock() && currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3)) {
70	condLoopContext.complainOnDeferredChecks(currentScope, condInfo);	74	condLoopContext.complainOnDeferredFinalChecks(currentScope,
		75	condInfo);
		76	condLoopContext.complainOnDeferredNullChecks(currentScope,
		77	condInfo.unconditionalInits());
71	if (isConditionTrue) {	78	if (isConditionTrue) {
72	return FlowInfo.DEAD_END;	79	return FlowInfo.DEAD_END;
73	} else {	80	} else {
74	FlowInfo mergedInfo = condInfo.initsWhenFalse().unconditionalInits();	81	FlowInfo mergedInfo = condInfo.initsWhenFalse();
75	if (isConditionOptimizedTrue){	82	if (isConditionOptimizedTrue){
76	mergedInfo.setReachMode(FlowInfo.UNREACHABLE);	83	mergedInfo.setReachMode(FlowInfo.UNREACHABLE);
77	}	84	}
78	mergedInitStateIndex =	85	mergedInitStateIndex =
79	currentScope.methodScope().recordInitializationStates(mergedInfo);	86	currentScope.methodScope().recordInitializationStates(mergedInfo);
80	return mergedInfo;	87	return flowInfo.unconditionalInits().
		88	addPotentialNullInfoFrom(
		89	condInfo.initsWhenFalse().unconditionalInits());
81	}	90	}
82	} else {	91	} else {
83	// in case the condition was inlined to false, record the fact that there is no way to reach any	92	// in case the condition was inlined to false, record the fact that there is no way to reach any
Lines 85-90 Link Here
85	loopingContext =	94	loopingContext =
86	new LoopingFlowContext(	95	new LoopingFlowContext(
87	flowContext,	96	flowContext,
		97	flowInfo,
88	this,	98	this,
89	breakLabel,	99	breakLabel,
90	continueLabel,	100	continueLabel,
Lines 108-122 Link Here
108	}	118	}
109		119
110	// code generation can be optimized when no need to continue in the loop	120	// code generation can be optimized when no need to continue in the loop
111	exitBranch = condInfo.initsWhenFalse();	121	exitBranch = flowInfo.copy();
112	exitBranch.addInitializationsFrom(flowInfo); // recover null inits from before condition analysis	122	// need to start over from flowInfo so as to get null inits
		123
113	if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {	124	if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {
114	continueLabel = null;	125	continueLabel = null;
		126	exitBranch.addInitializationsFrom(condInfo.initsWhenFalse());
115	} else {	127	} else {
116	condLoopContext.complainOnDeferredChecks(currentScope, condInfo);	128	condLoopContext.complainOnDeferredFinalChecks(currentScope,
		129	condInfo);
117	actionInfo = actionInfo.mergedWith(loopingContext.initsOnContinue.unconditionalInits());	130	actionInfo = actionInfo.mergedWith(loopingContext.initsOnContinue.unconditionalInits());
118	loopingContext.complainOnDeferredChecks(currentScope, actionInfo);	131	condLoopContext.complainOnDeferredNullChecks(currentScope,
119	exitBranch.addPotentialInitializationsFrom(actionInfo.unconditionalInits());	132	actionInfo);
		133	loopingContext.complainOnDeferredFinalChecks(currentScope,
		134	actionInfo);
		135	loopingContext.complainOnDeferredNullChecks(currentScope,
		136	actionInfo);
		137	exitBranch.
		138	addPotentialInitializationsFrom(
		139	actionInfo.unconditionalInits()).
		140	addInitializationsFrom(condInfo.initsWhenFalse());
120	}	141	}
121	}	142	}
122		143




				&& initsWhenFalse.isDefinitelyAssigned(local);
	}
	
public boolean isDefinitelyNonNull(LocalVariableBinding local) {
	return initsWhenTrue.isDefinitelyNonNull(local) 
			&& initsWhenFalse.isDefinitelyNonNull(local);
}
		
		return initsWhenTrue.isDefinitelyNonNull(field) 
				&& initsWhenFalse.isDefinitelyNonNull(field);
	}

	/**
	 * Check status of definite non-null assignment for a local variable.
	 */
	public boolean isDefinitelyNonNull(LocalVariableBinding local) {
		
		return initsWhenTrue.isDefinitelyNonNull(local) 
				&& initsWhenFalse.isDefinitelyNonNull(local);
	}
	
public boolean isDefinitelyNull(LocalVariableBinding local) {
	return initsWhenTrue.isDefinitelyNull(local) 
			&& initsWhenFalse.isDefinitelyNull(local);
}
		
		return initsWhenTrue.isDefinitelyNull(field) 
				&& initsWhenFalse.isDefinitelyNull(field);
	}

	/**
	 * Check status of definite null assignment for a local variable.
	 */
	public boolean isDefinitelyNull(LocalVariableBinding local) {
		
		return initsWhenTrue.isDefinitelyNull(local) 
				&& initsWhenFalse.isDefinitelyNull(local);
	}

public boolean isDefinitelyUnknown(LocalVariableBinding local) {
	return initsWhenTrue.isDefinitelyUnknown(local) 
			&& initsWhenFalse.isDefinitelyUnknown(local);
}
	public boolean isReachable(){
		
		return unconditionalInits().isReachable();	
		//should maybe directly be: false
	}
	
	/**
	 * Check status of potential assignment for a field.
	 */

				|| initsWhenFalse.isPotentiallyAssigned(local);
	}
	
public boolean isPotentiallyNull(LocalVariableBinding local) {
	return initsWhenTrue.isPotentiallyNull(local) 
		|| initsWhenFalse.isPotentiallyNull(local);
}	

public boolean isPotentiallyUnknown(LocalVariableBinding local) {
	return initsWhenTrue.isPotentiallyUnknown(local) 
		|| initsWhenFalse.isPotentiallyUnknown(local);
}	

public boolean isProtectedNonNull(LocalVariableBinding local) {
	return initsWhenTrue.isProtectedNonNull(local) 
		&& initsWhenFalse.isProtectedNonNull(local);
}		
	
public boolean isProtectedNull(LocalVariableBinding local) {
	return initsWhenTrue.isProtectedNull(local) 
		&& initsWhenFalse.isProtectedNull(local);
}		
	
public void markAsComparedEqualToNonNull(LocalVariableBinding local) {
	initsWhenTrue.markAsComparedEqualToNonNull(local);
	initsWhenFalse.markAsComparedEqualToNonNull(local);
}

public void markAsComparedEqualToNull(LocalVariableBinding local) {
	initsWhenTrue.markAsComparedEqualToNull(local);
    initsWhenFalse.markAsComparedEqualToNull(local);
}
	
	/**
	 * Record a field got definitely assigned.
	 */

		initsWhenFalse.markAsDefinitelyNull(local);	
	}

public void markAsDefinitelyUnknown(LocalVariableBinding local) {
	initsWhenTrue.markAsDefinitelyUnknown(local);
	initsWhenFalse.markAsDefinitelyUnknown(local);	
}

public FlowInfo setReachMode(int reachMode) {
	if (reachMode == REACHABLE) {
		this.tagBits &= ~UNREACHABLE;
	}
	else {
		this.tagBits |= UNREACHABLE;
	}
	initsWhenTrue.setReachMode(reachMode);
	initsWhenFalse.setReachMode(reachMode);
	return this;
}
	}
	
	public FlowInfo setReachMode(int reachMode) {
		
		initsWhenTrue.setReachMode(reachMode);
		initsWhenFalse.setReachMode(reachMode);
		return this;
	}
	
	/**
	 * Converts conditional receiver into inconditional one, updated in the following way: <ul>
	 * <li> intersection of definitely assigned variables, 
	 * <li> union of potentially assigned variables.
	 * </ul>
	 */
	public UnconditionalFlowInfo mergedWith(UnconditionalFlowInfo otherInits) {
		
		return unconditionalInits().mergedWith(otherInits);
	}
	
public UnconditionalFlowInfo mergedWith(UnconditionalFlowInfo otherInits) {
	return unconditionalInits().mergedWith(otherInits);
}

public UnconditionalFlowInfo nullInfoLessUnconditionalCopy() {
	return unconditionalInitsWithoutSideEffect().
		nullInfoLessUnconditionalCopy();
}
	public String toString() {
		
		return "FlowInfo<true: " + initsWhenTrue.toString() + ", false: " + initsWhenFalse.toString() + ">"; //$NON-NLS-1$ //$NON-NLS-3$ //$NON-NLS-2$
	}

public FlowInfo safeInitsWhenTrue() {
	return initsWhenTrue;
}

public UnconditionalFlowInfo unconditionalCopy() {
	return initsWhenTrue.unconditionalCopy().
			mergedWith(initsWhenFalse.unconditionalInits());
}

public UnconditionalFlowInfo unconditionalFieldLessCopy() {
	return initsWhenTrue.unconditionalFieldLessCopy().
		mergedWith(initsWhenFalse.unconditionalFieldLessCopy()); 
	// should never happen, hence suboptimal does not hurt
}

public UnconditionalFlowInfo unconditionalInits() {
	return initsWhenTrue.unconditionalInits().
			mergedWith(initsWhenFalse.unconditionalInits());
}

public UnconditionalFlowInfo unconditionalInitsWithoutSideEffect() {
	// cannot do better here than unconditionalCopy - but still a different 
	// operation for UnconditionalFlowInfo
	return initsWhenTrue.unconditionalCopy().
			mergedWith(initsWhenFalse.unconditionalInits());
}
}




			int cacheIndex = i / BitCacheSize, bitMask = 1 << (i % BitCacheSize);
			if (handledExceptions[i].isUncheckedException(true)) {
				isReached[cacheIndex] |= bitMask;
				this.initsOnExceptions[i] = flowInfo.unconditionalCopy();
			} else {
				this.initsOnExceptions[i] = FlowInfo.DEAD_END;
			}

		this.isReached[cacheIndex] |= bitMask;
		
		initsOnExceptions[index] =
			initsOnExceptions[index].isReachable() ?
				initsOnExceptions[index].mergedWith(flowInfo):
				flowInfo.unconditionalCopy();
	}
	
public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {
	if (!flowInfo.isReachable()) {
		return; 
	}
	if (initsOnReturn.isReachable()) {
		initsOnReturn = initsOnReturn.mergedWith(flowInfo);
	} 
	else {
		initsOnReturn = (UnconditionalFlowInfo) flowInfo.copy();
	}
}
	
	/*
	 * Compute a merged list of unhandled exception types (keeping only the most generic ones).




import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;

/**

	VariableBinding[] finalVariables;
	int assignCount;

	LocalVariableBinding[] nullLocals;	
	Expression[] nullReferences;
	int[] nullCheckTypes;
	int nullCount;
	
	public FinallyFlowContext(FlowContext parent, ASTNode associatedNode) {
		super(parent, associatedNode);
	}

/**
 * Given some contextual initialization info (derived from a try block or a catch block), this 
 * code will check that the subroutine context does not also initialize a final variable potentially set
 * redundantly.
 */
public void complainOnDeferredChecks(FlowInfo flowInfo, BlockScope scope) {
	
	// check redundant final assignments
	for (int i = 0; i < this.assignCount; i++) {
		VariableBinding variable = this.finalVariables[i];
		if (variable == null) continue;
		
		boolean complained = false; // remember if have complained on this final assignment
		if (variable instanceof FieldBinding) {
			// final field
			if (flowInfo.isPotentiallyAssigned((FieldBinding)variable)) {
				complained = true;
				scope.problemReporter().duplicateInitializationOfBlankFinalField((FieldBinding)variable, finalAssignments[i]);
			}
		} else {
			// final local variable
			if (flowInfo.isPotentiallyAssigned((LocalVariableBinding) variable)) {
				complained = true;
				scope.problemReporter().duplicateInitializationOfFinalLocal(
					(LocalVariableBinding) variable,
					this.finalAssignments[i]);
				if (flowInfo.isPotentiallyAssigned((LocalVariableBinding) variable)) {
					complained = true;
					scope.problemReporter().duplicateInitializationOfFinalLocal(
						(LocalVariableBinding) variable,
						finalAssignments[i]);
				}
			}
			// any reference reported at this level is removed from the parent context 
			// where it could also be reported again
			if (complained) {
				FlowContext currentContext = parent;
				while (currentContext != null) {
					//if (currentContext.isSubRoutine()) {
					currentContext.removeFinalAssignmentIfAny(finalAssignments[i]);
					//}
					currentContext = currentContext.parent;
				}
			}
		}
		// any reference reported at this level is removed from the parent context 
		// where it could also be reported again
		if (complained) {
			FlowContext currentContext = this.parent;
			while (currentContext != null) {
				//if (currentContext.isSubRoutine()) {
				currentContext.removeFinalAssignmentIfAny(this.finalAssignments[i]);
				//}
				currentContext = currentContext.parent;
			}
		}
	}
	
	// check inconsistent null checks
	if (this.deferNullDiagnostic) { // within an enclosing loop, be conservative
		for (int i = 0; i < this.nullCount; i++) {
			Expression expression = this.nullReferences[i];
			LocalVariableBinding local = this.nullLocals[i];
			switch (this.nullCheckTypes[i]) {
				case CAN_ONLY_NULL_NON_NULL :
				case CAN_ONLY_NULL:
					if (flowInfo.isProtectedNonNull(local)) {
						if (nullCheckTypes[i] == CAN_ONLY_NULL_NON_NULL) {
							scope.problemReporter().localVariableCannotBeNull(local, expression);
						}
						return;
					}
					if (flowInfo.isProtectedNull(local)) {
						scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
						return;
					}
					break;
				case MAY_NULL :
					if (flowInfo.isProtectedNonNull(local)) {
						return;
					}
					if (flowInfo.isProtectedNull(local)) {
						scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
						return;
					}
					break;
				default:
					// never happens
			}
			this.parent.recordUsingNullReference(scope, local, expression, 
					this.nullCheckTypes[i], flowInfo);
		}
	}
	else { // no enclosing loop, be as precise as possible right now
		for (int i = 0; i < this.nullCount; i++) {
			Expression expression = this.nullReferences[i];
			// final local variable
			LocalVariableBinding local = this.nullLocals[i];
			switch (this.nullCheckTypes[i]) {
				case CAN_ONLY_NULL_NON_NULL :
					if (flowInfo.isDefinitelyNonNull(local)) {
						scope.problemReporter().localVariableCannotBeNull(local, expression);				
						return;
					}
				case CAN_ONLY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
						return;
					}
					break;
				case MAY_NULL :
					if (flowInfo.isDefinitelyNull(local)) {
						scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
						return;
					}
					if (flowInfo.isPotentiallyNull(local)) {
						scope.problemReporter().localVariableMayBeNull(local, expression);
						return;
					}
					break;
				default:
					// should not happen
			}
		}
	}
}
	
	public String individualToString() {
		

		return true;
	}

	public void recordUsingNullReference(Scope scope, LocalVariableBinding local, 
			Expression reference, int checkType, FlowInfo flowInfo) {
		if (!flowInfo.isReachable()) {
			return;
		}
		if (deferNullDiagnostic) { // within an enclosing loop, be conservative
			switch (checkType) {
				case CAN_ONLY_NULL_NON_NULL :
				case CAN_ONLY_NULL:
					if (flowInfo.isProtectedNonNull(local)) {
						if (checkType == CAN_ONLY_NULL_NON_NULL) {
							scope.problemReporter().localVariableCannotBeNull(local, reference);
						}
						return;
					}
					if (flowInfo.isProtectedNull(local)) {
						scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
						return;
					}
					break;
				case MAY_NULL :
					if (flowInfo.isProtectedNonNull(local)) {
						return;
					}
					if (flowInfo.isProtectedNull(local)) {
						scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
						return;
					}
					break;
				default:
					// never happens
			}
		}
		else { // no enclosing loop, be as precise as possible right now
			switch (checkType) {
				case CAN_ONLY_NULL_NON_NULL :
					if (flowInfo.isDefinitelyNonNull(local)) {
						scope.problemReporter().localVariableCannotBeNull(local, reference);				
						return;
					}
				case CAN_ONLY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
						return;
					}
					break;
				case MAY_NULL :
					if (flowInfo.isDefinitelyNull(local)) {
						scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
						return;
					}
					if (flowInfo.isPotentiallyNull(local)) {
						scope.problemReporter().localVariableMayBeNull(local, reference);
						return;
					}
					if (flowInfo.isDefinitelyNonNull(local)) {
						return; // shortcut: cannot be null
					}
					break;
				default:
					// never happens
			}
		}
		recordNullReference(local, reference, checkType); 
		// prepare to re-check with try/catch flow info 
	}
	
	void removeFinalAssignmentIfAny(Reference reference) {
		for (int i = 0; i < assignCount; i++) {
			if (finalAssignments[i] == reference) {

		}
	}

protected void recordNullReference(LocalVariableBinding local, 
	Expression expression, int status) {
	if (this.nullCount == 0) {
		this.nullLocals = new LocalVariableBinding[5];
		this.nullReferences = new Expression[5];
		this.nullCheckTypes = new int[5];
	} 
	else if (this.nullCount == this.nullLocals.length) {
		int newLength = this.nullCount * 2;
		System.arraycopy(this.nullLocals, 0, 
			this.nullLocals = new LocalVariableBinding[newLength], 0, 
			this.nullCount);
		System.arraycopy(this.nullReferences, 0, 
			this.nullReferences = new Expression[newLength], 0,
			this.nullCount);
		System.arraycopy(this.nullCheckTypes, 0, 
			this.nullCheckTypes = new int[newLength], 0, 
			this.nullCount);
	}
	this.nullLocals[this.nullCount] = local;
	this.nullReferences[this.nullCount] = expression;
	this.nullCheckTypes[this.nullCount++] = status;
}
}

Lines 35-46 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/FlowContext.java (-24 / +75 lines)
35		35
36	public ASTNode associatedNode;	36	public ASTNode associatedNode;
37	public FlowContext parent;	37	public FlowContext parent;
38		38	boolean deferNullDiagnostic, preemptNullDiagnostic;
		39	// preempt marks looping contexts
39	public final static FlowContext NotContinuableContext = new FlowContext(null, null);	40	public final static FlowContext NotContinuableContext = new FlowContext(null, null);
40		41
41	public FlowContext(FlowContext parent, ASTNode associatedNode) {	42	public FlowContext(FlowContext parent, ASTNode associatedNode) {
42	this.parent = parent;	43	this.parent = parent;
43	this.associatedNode = associatedNode;	44	this.associatedNode = associatedNode;
		45	deferNullDiagnostic = parent != null &&
		46	(parent.deferNullDiagnostic \|\| parent.preemptNullDiagnostic);
44	}	47	}
45		48
46	public Label breakLabel() {	49	public Label breakLabel() {
Lines 163-169 Link Here
163	traversedContext.recordReturnFrom(flowInfo.unconditionalInits());	166	traversedContext.recordReturnFrom(flowInfo.unconditionalInits());
164	if (traversedContext.associatedNode instanceof TryStatement){	167	if (traversedContext.associatedNode instanceof TryStatement){
165	TryStatement tryStatement = (TryStatement) traversedContext.associatedNode;	168	TryStatement tryStatement = (TryStatement) traversedContext.associatedNode;
166	flowInfo = flowInfo.copy().addInitializationsFrom(tryStatement.subRoutineInits);	169	flowInfo = flowInfo.addInitializationsFrom(tryStatement.subRoutineInits);
167	}	170	}
168	traversedContext = traversedContext.parent;	171	traversedContext = traversedContext.parent;
169	}	172	}
Lines 256-262 Link Here
256	traversedContext.recordReturnFrom(flowInfo.unconditionalInits());	259	traversedContext.recordReturnFrom(flowInfo.unconditionalInits());
257	if (traversedContext.associatedNode instanceof TryStatement){	260	if (traversedContext.associatedNode instanceof TryStatement){
258	TryStatement tryStatement = (TryStatement) traversedContext.associatedNode;	261	TryStatement tryStatement = (TryStatement) traversedContext.associatedNode;
259	flowInfo = flowInfo.copy().addInitializationsFrom(tryStatement.subRoutineInits);	262	flowInfo = flowInfo.addInitializationsFrom(tryStatement.subRoutineInits);
260	}	263	}
261	traversedContext = traversedContext.parent;	264	traversedContext = traversedContext.parent;
262	}	265	}
Lines 403-409 Link Here
403	// default implementation: do nothing	406	// default implementation: do nothing
404	}	407	}
405		408
406	public void recordContinueFrom(FlowInfo flowInfo) {	409	public void recordContinueFrom(FlowContext innerFlowContext, FlowInfo flowInfo) {
407	// default implementation: do nothing	410	// default implementation: do nothing
408	}	411	}
409		412
Lines 411-421 Link Here
411	return true; // keep going	414	return true; // keep going
412	}	415	}
413		416
414	protected boolean recordNullReference(Expression expression, int status) {	417	/**
415	return false; // keep going	418	* Record a null reference for use by deferred checks. Only looping or
		419	* finally contexts really record that information.
		420	* @param local the local variable involved in the check
		421	* @param expression the expression within which local lays
		422	* @param status the status against which the check must be performed; one of
		423	* {@link #CAN_ONLY_NULL CAN_ONLY_NULL}, {@link #CAN_ONLY_NULL_NON_NULL
		424	* CAN_ONLY_NULL_NON_NULL}, {@link #MAY_NULL MAY_NULL}
		425	*/
		426	protected void recordNullReference(LocalVariableBinding local,
		427	Expression expression, int status) {
		428	// default implementation: do nothing
416	}	429	}
417		430
418	public void recordReturnFrom(FlowInfo flowInfo) {	431	public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {
419	// default implementation: do nothing	432	// default implementation: do nothing
420	}	433	}
421		434
Lines 432-465 Link Here
432	}	445	}
433	}	446	}
434		447
435	public void recordUsingNullReference(Scope scope, LocalVariableBinding local, Expression reference, int status, FlowInfo flowInfo) {	448	public static final int
436	if (!flowInfo.isReachable()) return;	449	CAN_ONLY_NULL_NON_NULL = 20,
437		450	// check against null and non null, with definite values -- comparisons
438	switch (status) {	451	CAN_ONLY_NULL = 21,
439	case FlowInfo.NULL :	452	// check against null, with definite values -- assignment to null
		453	MAY_NULL = 22;
		454	// check against null, with potential values -- NPE guard
		455
		456	/**
		457	* Record a null reference for use by deferred checks. Only looping or
		458	* finally contexts really record that information. The context may
		459	* emit an error immediately depending on the status of local against
		460	* flowInfo and its nature (only looping of finally contexts defer part
		461	* of the checks; nonetheless, contexts that are nested into a looping or a
		462	* finally context get affected and delegate some checks to their enclosing
		463	* context).
		464	* @param scope the scope into which the check is performed
		465	* @param local the local variable involved in the check
		466	* @param reference the expression within which local lays
		467	* @param checkType the status against which the check must be performed; one
		468	* of {@link #CAN_ONLY_NULL CAN_ONLY_NULL}, {@link #CAN_ONLY_NULL_NON_NULL
		469	* CAN_ONLY_NULL_NON_NULL}, {@link #MAY_NULL MAY_NULL}
		470	* @param flowInfo the flow info at the check point; deferring contexts will
		471	* perform supplementary checks against flow info instances that cannot
		472	* be known at the time of calling this method (they are influenced by
		473	* code that follows the current point)
		474	*/
		475	public void recordUsingNullReference(Scope scope, LocalVariableBinding local,
		476	Expression reference, int checkType, FlowInfo flowInfo) {
		477	if (!flowInfo.isReachable() \|\| flowInfo.isDefinitelyUnknown(local)) {
		478	return;
		479	}
		480	switch (checkType) {
		481	case CAN_ONLY_NULL_NON_NULL :
		482	if (flowInfo.isDefinitelyNonNull(local)) {
		483	scope.problemReporter().localVariableCannotBeNull(local, reference);
		484	return;
		485	}
		486	else if (flowInfo.isPotentiallyUnknown(local)) {
		487	return;
		488	}
		489	case CAN_ONLY_NULL:
440	if (flowInfo.isDefinitelyNull(local)) {	490	if (flowInfo.isDefinitelyNull(local)) {
441	scope.problemReporter().localVariableCanOnlyBeNull(local, reference);	491	scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
442	return;	492	return;
443	} else if (flowInfo.isDefinitelyNonNull(local)) {	493	}
444	scope.problemReporter().localVariableCannotBeNull(local, reference);	494	else if (flowInfo.isPotentiallyUnknown(local)) {
445	return;	495	return;
446	}	496	}
447	break;	497	break;
448	case FlowInfo.NON_NULL :	498	case MAY_NULL :
449	if (flowInfo.isDefinitelyNull(local)) {	499	if (flowInfo.isDefinitelyNull(local)) {
450	scope.problemReporter().localVariableCanOnlyBeNull(local, reference);	500	scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
		501	return;
		502	}
		503	if (flowInfo.isPotentiallyNull(local)) {
		504	scope.problemReporter().localVariableMayBeNull(local, reference);
451	return;	505	return;
452	}	506	}
453	break;	507	break;
		508	default:
		509	// never happens
454	}	510	}
455		511	if (parent != null) {
456	// for initialization inside looping statement that effectively loops	512	parent.recordUsingNullReference(scope, local, reference, checkType,
457	FlowContext context = this;	513	flowInfo);
458	while (context != null) {
459	if (context.recordNullReference(reference, status)) {
460	return; // no need to keep going
461	}
462	context = context.parent;
463	}	514	}
464	}	515	}
465		516





public abstract class FlowInfo {

	public int tagBits; // REACHABLE by default
	public final static int REACHABLE = 0;
	public final static int UNREACHABLE = 1;
	public final static int NULL_FLAG_MASK = 2;
	
	public final static int UNKNOWN = 0;
	public final static int NULL = 1;

	public static final UnconditionalFlowInfo DEAD_END; // Represents a dead branch status of initialization
	static {
		DEAD_END = new UnconditionalFlowInfo();
		DEAD_END.tagBits = UNREACHABLE;
	}
	abstract public FlowInfo addInitializationsFrom(FlowInfo otherInits);

/**
 * Add other inits to this flow info, then return this. The operation semantics
 * are to match as closely as possible the application to this flow info of all
 * the operations that resulted into otherInits. 
 * @param otherInits other inits to add to this
 * @return this, modified according to otherInits information
 */
abstract public FlowInfo addInitializationsFrom(FlowInfo otherInits);


/**
 * Compose other inits over this flow info, then return this. The operation
 * semantics are to wave into this flow info the consequences of a possible
 * path into the operations that resulted into otherInits. The fact that this
 * path may be left unexecuted under peculiar conditions results into less
 * specific results than {@link #addInitializationsFrom(FlowInfo) 
 * addInitializationsFrom}.
 * @param otherInits other inits to compose over this
 * @return this, modified according to otherInits information
 */
abstract public FlowInfo addPotentialInitializationsFrom(FlowInfo otherInits);

	public FlowInfo asNegatedCondition() {


		return new ConditionalFlowInfo(initsWhenTrue, initsWhenFalse);
	}

/**
 * Return a deep copy of the current instance.
 * @return a deep copy of this flow info
 */
	abstract public FlowInfo copy();

	public static UnconditionalFlowInfo initial(int maxFieldCount) {

		info.maxFieldCount = maxFieldCount;
		return info;
	}
	
/**
 * Return the flow info that would result from the path associated to the
 * value false for the condition expression that generated this flow info.
 * May be this flow info if it is not an instance of {@link 
 * ConditionalFlowInfo}. May have a side effect on subparts of this flow
 * info (subtrees get merged).
 * @return the flow info associated to the false branch of the condition
 * 			that generated this flow info
 */
abstract public FlowInfo initsWhenFalse();

/**
 * Return the flow info that would result from the path associated to the
 * value true for the condition expression that generated this flow info.
 * May be this flow info if it is not an instance of {@link 
 * ConditionalFlowInfo}. May have a side effect on subparts of this flow
 * info (subtrees get merged).
 * @return the flow info associated to the true branch of the condition
 * 			that generated this flow info
 */
	abstract public FlowInfo initsWhenTrue();

	/**

	 */
	public abstract boolean isDefinitelyAssigned(LocalVariableBinding local);

/**
 * Check status of definite non-null value for a given local variable.
 * @param local the variable to ckeck
 * @return true iff local is definitely non null for this flow info
 */
	/**
	 * Check status of definite null assignment for a local.
	 */
	public abstract boolean isDefinitelyNonNull(LocalVariableBinding local);

/**
 * Check status of definite null value for a given local variable.
 * @param local the variable to ckeck
 * @return true iff local is definitely null for this flow info
 */
public abstract boolean isDefinitelyNull(LocalVariableBinding local);

/**
 * Check status of definite unknown value for a given local variable.
 * @param local the variable to ckeck
 * @return true iff local is definitely unknown for this flow info
 */
public abstract boolean isDefinitelyUnknown(LocalVariableBinding local);

	/**
	 * Check status of potential assignment for a field.


	 abstract public boolean isPotentiallyAssigned(LocalVariableBinding field);   

/**
 * Check status of potential null assignment for a local.
 */
public abstract boolean isPotentiallyNull(LocalVariableBinding local);
	
/**
 * Return true if the given local may have been assigned to an unknown value.
 * @param local the local to check
 * @return true if the given local may have been assigned to an unknown value
 */
public abstract boolean isPotentiallyUnknown(LocalVariableBinding local);

/**
 * Return true if the given local is protected by a test against a non null
 * value.
 * @param local the local to check
 * @return true if the given local is protected by a test against a non null
 */
public abstract boolean isProtectedNonNull(LocalVariableBinding local);

/**
 * Return true if the given local is protected by a test against null.
 * @param local the local to check
 * @return true if the given local is protected by a test against null
 */
public abstract boolean isProtectedNull(LocalVariableBinding local);

public boolean isReachable() {
	return (this.tagBits & UNREACHABLE) == 0;
}

/**
 * Record that a local variable got checked to be non null.
 * @param local the checked local variable
 */
abstract public void markAsComparedEqualToNonNull(LocalVariableBinding local);
	
/**
 * Record that a local variable got checked to be null.
 * @param local the checked local variable
 */
abstract public void markAsComparedEqualToNull(LocalVariableBinding local);
	
	/**
	 * Record a field got definitely assigned.

	abstract public void markAsDefinitelyNull(LocalVariableBinding local);

	/**
	 * Record a field got definitely assigned to null.
	 */
	abstract public void markAsDefinitelyNull(FieldBinding field);


	 */
	abstract public void markAsDefinitelyAssigned(LocalVariableBinding local);

/**
 * Record a local got definitely assigned to an unknown value.
 */
abstract public void markAsDefinitelyUnknown(LocalVariableBinding local);

/**
 * Merge branches using optimized boolean conditions
 */
public static UnconditionalFlowInfo mergedOptimizedBranches(
		FlowInfo initsWhenTrue, boolean isOptimizedTrue, 
		FlowInfo initsWhenFalse, boolean isOptimizedFalse, 
		boolean allowFakeDeadBranch) {
	UnconditionalFlowInfo mergedInfo;
	if (isOptimizedTrue){
		if (initsWhenTrue == FlowInfo.DEAD_END && allowFakeDeadBranch) {
			mergedInfo = initsWhenFalse.setReachMode(FlowInfo.UNREACHABLE).
				unconditionalInits();
		} 
		else {
			mergedInfo = 
				initsWhenTrue.addPotentialInitializationsFrom(initsWhenFalse.
					nullInfoLessUnconditionalCopy()).
				unconditionalInits();
		}
	} 
	else if (isOptimizedFalse) {
		if (initsWhenFalse == FlowInfo.DEAD_END && allowFakeDeadBranch) {
			mergedInfo = initsWhenTrue.setReachMode(FlowInfo.UNREACHABLE).
				unconditionalInits();
		} 
		else {
			mergedInfo = 
				initsWhenFalse.addPotentialInitializationsFrom(initsWhenTrue.
					nullInfoLessUnconditionalCopy()).
				unconditionalInits();
		}
	} 
	else {
		mergedInfo = initsWhenTrue.
			mergedWith(initsWhenFalse.unconditionalInits());
	}
	return mergedInfo;
}
	
/**
 * Return REACHABLE if this flow info is reachable, UNREACHABLE
 * else.
 * @return REACHABLE if this flow info is reachable, UNREACHABLE
 *         else
 */
public int reachMode() {
	return this.tagBits & UNREACHABLE;
}
	
/**
 * Return a flow info that carries the same information as the result of
 * {@link #initsWhenTrue() initsWhenTrue}, but warrantied to be different 
 * from this.<br>
 * Caveat: side effects on the result may affect components of this. 
 * @return the result of initsWhenTrue or a copy of it
 */
abstract public FlowInfo safeInitsWhenTrue();

/**
 * Set this flow info reach mode and return this.
 * @param reachMode one of {@link #REACHABLE REACHABLE} or {@link #UNREACHABLE UNREACHABLE}
 * @return this, with the reach mode set to reachMode
 */
abstract public FlowInfo setReachMode(int reachMode);

/**
 * Return the intersection of this and otherInits, that is 
 * one of:<ul>
 *   <li>the receiver updated in the following way:<ul>
 *     <li>intersection of definitely assigned variables, 
 *     <li>union of potentially assigned variables,
 *     <li>similar operations for null,</ul>
 *   <li>or the receiver or otherInits if the other one is non
 *       reachable.</ul>
 * otherInits is not affected, and is not returned either (no
 * need to protect the result).
 * @param otherInits the flow info to merge with this
 * @return the intersection of this and otherInits.
 */
abstract public UnconditionalFlowInfo mergedWith(
		UnconditionalFlowInfo otherInits);

/**
 * Return a copy of this unconditional flow info, deprived from its null
 * info. {@link #DEAD_END DEAD_END} is returned unmodified.
 * @return a copy of this unconditional flow info deprived from its null info
 */
abstract public UnconditionalFlowInfo nullInfoLessUnconditionalCopy();

	public String toString(){


		return super.toString();
	}

/**
 * Return a new flow info that holds the same information as this would after
 * a call to unconditionalInits, but leaving this info unaffected. Moreover,
 * the result can be modified without affecting this.
 * @return a new flow info carrying this unconditional flow info
 */
abstract public UnconditionalFlowInfo unconditionalCopy();

/**
 * Return a new flow info that holds the same information as this would after
 * a call to {@link #unconditionalInits() unconditionalInits} followed by the 
 * erasure of fields specific information, but leaving this flow info unaffected.
 * @return a new flow info carrying the unconditional flow info for local variables
 */
abstract public UnconditionalFlowInfo unconditionalFieldLessCopy();

/**
 * Return a flow info that merges the possible paths of execution described by
 * this flow info. In case of an unconditional flow info, return this. In case
 * of a conditional flow info, merge branches recursively. Caveat: this may
 * be affected, and modifying the result may affect this. 
 * @return a flow info that merges the possible paths of execution described by
 * 			this
 */
abstract public UnconditionalFlowInfo unconditionalInits();

/**
 * Return a new flow info that holds the same information as this would after
 * a call to {@link #unconditionalInits() unconditionalInits}, but leaving 
 * this info unaffected. Side effects on the result might affect this though 
 * (consider it as read only).
 * @return a flow info carrying this unconditional flow info
 */
abstract public UnconditionalFlowInfo unconditionalInitsWithoutSideEffect();
}




		return (SubRoutineStatement)associatedNode;
	}
	
public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {
	if (!flowInfo.isReachable()) {
		return; 
		if (initsOnReturn == FlowInfo.DEAD_END) {
			initsOnReturn = flowInfo.copy().unconditionalInits();
		} else {
			initsOnReturn = initsOnReturn.mergedWith(flowInfo.copy().unconditionalInits());
		}
	}
	if (initsOnReturn == FlowInfo.DEAD_END) {
		initsOnReturn = (UnconditionalFlowInfo) flowInfo.copy();
	} else {
		initsOnReturn = initsOnReturn.mergedWith(flowInfo);
	}
}
}




	
	public Label continueLabel;
	public UnconditionalFlowInfo initsOnContinue = FlowInfo.DEAD_END;
	private UnconditionalFlowInfo upstreamNullFlowInfo;
	private LoopingFlowContext innerFlowContexts[] = null;
	private UnconditionalFlowInfo innerFlowInfos[] = null;
	private int innerFlowContextsNb = 0;
	
	Reference finalAssignments[];
	VariableBinding finalVariables[];
	int assignCount = 0;
	
	LocalVariableBinding[] nullLocals;
	Expression[] nullReferences;
	int[] nullCheckTypes;
	int nullCount;
	
	Scope associatedScope;
	
	public LoopingFlowContext(
		FlowContext parent,
		FlowInfo upstreamNullFlowInfo,
		ASTNode associatedNode,
		Label breakLabel,
		Label continueLabel,
		Scope associatedScope) {
		super(parent, associatedNode, breakLabel);
		preemptNullDiagnostic = true; 
			// children will defer to this, which may defer to its own parent 
		this.continueLabel = continueLabel;
		this.associatedScope = associatedScope;
		this.upstreamNullFlowInfo = upstreamNullFlowInfo.unconditionalCopy();
	}

/**
 * Perform deferred checks relative to final variables duplicate initialization 
 * of lack of initialization.
 * @param scope the scope to which this context is associated
 * @param flowInfo the flow info against which checks must be performed
 */
public void complainOnDeferredFinalChecks(BlockScope scope, FlowInfo flowInfo) {
	// complain on final assignments in loops
	for (int i = 0; i < assignCount; i++) {
		VariableBinding variable = finalVariables[i];
		if (variable == null) continue;
		boolean complained = false; // remember if have complained on this final assignment
		if (variable instanceof FieldBinding) {
			if (flowInfo.isPotentiallyAssigned((FieldBinding) variable)) {
				complained = true;
				scope.problemReporter().duplicateInitializationOfBlankFinalField(
					(FieldBinding) variable,
					finalAssignments[i]);
						(LocalVariableBinding) variable,
						finalAssignments[i]);
				}
			}
		} else {
			if (flowInfo.isPotentiallyAssigned((LocalVariableBinding) variable)) {
				complained = true;
				scope.problemReporter().duplicateInitializationOfFinalLocal(
					(LocalVariableBinding) variable,
					finalAssignments[i]);
					context = context.parent;
				}
			}
		}
		// any reference reported at this level is removed from the parent context where it 
		// could also be reported again
		if (complained) {
			FlowContext context = parent;
			while (context != null) {
				context.removeFinalAssignmentIfAny(finalAssignments[i]);
				context = context.parent;
			}
		}
	}
}

/**
 * Perform deferred checks relative to the null status of local variables.
 * @param scope the scope to which this context is associated
 * @param flowInfo the flow info against which checks must be performed
 */
public void complainOnDeferredNullChecks(BlockScope scope, FlowInfo flowInfo) {
	for (int i = 0 ; i < this.innerFlowContextsNb ; i++) {
		this.upstreamNullFlowInfo.
			addPotentialNullInfoFrom(
				this.innerFlowContexts[i].upstreamNullFlowInfo).
			addPotentialNullInfoFrom(this.innerFlowInfos[i]);
	}
	this.innerFlowContextsNb = 0;
	flowInfo = this.upstreamNullFlowInfo.
		addPotentialNullInfoFrom(
			flowInfo.unconditionalInitsWithoutSideEffect());
	if (this.deferNullDiagnostic) {
		// check only immutable null checks on innermost looping context
		for (int i = 0; i < this.nullCount; i++) {
			LocalVariableBinding local = this.nullLocals[i];
			Expression expression = this.nullReferences[i];
			// final local variable
			switch (this.nullCheckTypes[i]) {
				case CAN_ONLY_NULL_NON_NULL :
					if (flowInfo.isDefinitelyNonNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().localVariableCannotBeNull(local, expression);
						continue;
					}
				case CAN_ONLY_NULL :
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
						continue;
					}
					break;
				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
						continue;
					}
					break;
				default:
					// never happens	
			}
			this.parent.recordUsingNullReference(scope, local, expression, 
					this.nullCheckTypes[i], flowInfo);
		}
	}
	else {
		// check inconsistent null checks on outermost looping context
		for (int i = 0; i < this.nullCount; i++) {
			Expression expression = this.nullReferences[i];
			// final local variable
			LocalVariableBinding local = this.nullLocals[i];
			switch (this.nullCheckTypes[i]) {
				case CAN_ONLY_NULL_NON_NULL :
					if (flowInfo.isDefinitelyNonNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().localVariableCannotBeNull(local, expression);
						continue;
					}
				case CAN_ONLY_NULL :
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
						continue;
					}
					break;
				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
						continue;
					}
					if (flowInfo.isPotentiallyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().localVariableMayBeNull(local, expression);
						continue;
					}
					break;
				default:
					// never happens	
			}
		}
	}
}
	
	public Label continueLabel() {
		return continueLabel;
	}

		return initsOnContinue != FlowInfo.DEAD_END;
	}

public void recordContinueFrom(FlowContext innerFlowContext, FlowInfo flowInfo) {
	if (!flowInfo.isReachable()) {
		return;
	}
	if (initsOnContinue.isReachable()) {
		initsOnContinue = initsOnContinue.
			mergedWith(flowInfo.unconditionalInitsWithoutSideEffect());
	} 
	else {
		initsOnContinue = flowInfo.unconditionalCopy();
	}
	FlowContext inner = innerFlowContext;
	while (inner != this && !(inner instanceof LoopingFlowContext)) {
		inner = inner.parent;
	}
	if (inner == this) {
		this.upstreamNullFlowInfo.
			addPotentialNullInfoFrom(
				flowInfo.unconditionalInitsWithoutSideEffect());
	}
	else {
		int length = 0;
		if (this.innerFlowContexts == null) {
			this.innerFlowContexts = new LoopingFlowContext[5];
			this.innerFlowInfos = new UnconditionalFlowInfo[5];
		}
		else if (this.innerFlowContextsNb == 
				(length = this.innerFlowContexts.length) - 1) {
			System.arraycopy(this.innerFlowContexts, 0, 
				(this.innerFlowContexts = new LoopingFlowContext[length + 5]), 
				0, length);
			System.arraycopy(this.innerFlowInfos, 0, 
				(this.innerFlowInfos= new UnconditionalFlowInfo[length + 5]), 
				0, length);
		}
		this.innerFlowContexts[this.innerFlowContextsNb] = (LoopingFlowContext) inner;
		this.innerFlowInfos[this.innerFlowContextsNb++] = 
			flowInfo.unconditionalInitsWithoutSideEffect();
	}
}

	protected boolean recordFinalAssignment(
		VariableBinding binding,

		return true;
	}

protected void recordNullReference(LocalVariableBinding local, 
	Expression expression, int status) {
	if (nullCount == 0) {
		nullLocals = new LocalVariableBinding[5];
		nullReferences = new Expression[5];
		nullCheckTypes = new int[5];
	} 
	else if (nullCount == nullLocals.length) {
		System.arraycopy(nullLocals, 0, 
			nullLocals = new LocalVariableBinding[nullCount * 2], 0, nullCount);
		System.arraycopy(nullReferences, 0, 
			nullReferences = new Expression[nullCount * 2], 0, nullCount);
		System.arraycopy(nullCheckTypes, 0, 
			nullCheckTypes = new int[nullCount * 2], 0, nullCount);
	}
	nullLocals[nullCount] = local;
	nullReferences[nullCount] = expression;
	nullCheckTypes[nullCount++] = status;
}
	
public void recordUsingNullReference(Scope scope, LocalVariableBinding local,
		Expression reference, int checkType, FlowInfo flowInfo) {
	if (!flowInfo.isReachable() || flowInfo.isDefinitelyUnknown(local)) {
		return;
	}
	switch (checkType) {
		case CAN_ONLY_NULL_NON_NULL :
		case CAN_ONLY_NULL:
			if (flowInfo.isDefinitelyNonNull(local)) {
				if (checkType == CAN_ONLY_NULL_NON_NULL) {
					scope.problemReporter().localVariableCannotBeNull(local, reference);
				}
				return;
			}
			if (flowInfo.isDefinitelyNull(local)) {
				scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
				return;
			}
			if (flowInfo.isPotentiallyUnknown(local)) {
				return;
			}
			recordNullReference(local, reference, checkType);
			return;
		case MAY_NULL :
			if (flowInfo.isDefinitelyNonNull(local)) {
				return;
			}
			if (flowInfo.isDefinitelyNull(local)) {
				scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
				return;
			}
			if (flowInfo.isPotentiallyNull(local)) {
				scope.problemReporter().localVariableMayBeNull(local, reference);
				return;
			}
			recordNullReference(local, reference, checkType);
			return;
		default:
			// never happens
	}
}
	
	void removeFinalAssignmentIfAny(Reference reference) {
		for (int i = 0; i < assignCount; i++) {

Lines 42-51 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/SwitchFlowContext.java (-4 / +5 lines)
42	}	42	}
43		43
44	public void recordBreakFrom(FlowInfo flowInfo) {	44	public void recordBreakFrom(FlowInfo flowInfo) {
45	if (initsOnBreak == FlowInfo.DEAD_END) {	45	if (initsOnBreak.isReachable()) {
46	initsOnBreak = flowInfo.copy().unconditionalInits();	46	initsOnBreak = initsOnBreak.mergedWith(flowInfo.unconditionalInits());
47	} else {	47	}
48	initsOnBreak = initsOnBreak.mergedWith(flowInfo.copy().unconditionalInits());	48	else {
		49	initsOnBreak = flowInfo.unconditionalCopy();
49	}	50	}
50	}	51	}
51	}	52	}




import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;


/**
 * Record initialization status during definite assignment analysis

 */
public class UnconditionalFlowInfo extends FlowInfo {

	
	public long definiteInits;
	public long potentialInits;
	public long extraDefiniteInits[];
	public long extraPotentialInits[];
	
	public long nullAssignmentStatusBit1;
	public long nullAssignmentStatusBit2;
	// 0 0 is potential (bit 1 is leftmost here)
	// 1 0 is assigned
	// 0 1 is protected null (aka if (o == null) { // here o protected null...)
	// 1 1 is protected non null
	public long nullAssignmentValueBit1;
	public long nullAssignmentValueBit2;
	// information only relevant for potential and assigned
	// 0 0 is start -- nothing known at all
	// 0 1 is assigned non null or potential anything but null
	// 1 0 is assigned null or potential null
	// 1 1 is potential null and potential anything but null or definite unknown

	public static final int extraLength = 6;
	public long extra[][];
		// extra bit fields for larger numbers of fields/variables
		// extra[0] holds definiteInits values, extra[1] potentialInits, etc.
		// lifecycle is extra == null or else all extra[]'s are allocated
		// arrays which have the same size

	public int maxFieldCount; // limit between fields and locals
	
	// Constants
	public static final int BitCacheSize = 64; // 64 bits in a long.

public FlowInfo addInitializationsFrom(FlowInfo inits) {
	if (this == DEAD_END)
		return this;
	if (inits == DEAD_END)
		return this;
	UnconditionalFlowInfo otherInits = inits.unconditionalInits();		

	// union of definitely assigned variables, 
	this.definiteInits |= otherInits.definiteInits;
	// union of potentially set ones
	this.potentialInits |= otherInits.potentialInits;
	// combine null information
	// note: we may have both forms of protection (null and non null) 
	// coming with otherInits, because of loops
	boolean considerNulls = (otherInits.tagBits & NULL_FLAG_MASK) != 0;
	long a1, na1, a2, na2, a3, a4, na4, b1, b2, nb2, b3, nb3, b4, nb4;
	if (considerNulls) {
		if ((this.tagBits & NULL_FLAG_MASK) == 0) {
			this.nullAssignmentStatusBit1 = otherInits.nullAssignmentStatusBit1;
			this.nullAssignmentStatusBit2 = otherInits.nullAssignmentStatusBit2;
			this.nullAssignmentValueBit1 = otherInits.nullAssignmentValueBit1;
			this.nullAssignmentValueBit2 = otherInits.nullAssignmentValueBit2;
		}
		else {
			this.nullAssignmentStatusBit1 =
				(b1 = otherInits.nullAssignmentStatusBit1) |
				(a1	 = this.nullAssignmentStatusBit1) & 
					((nb2 = ~(b2 = otherInits.nullAssignmentStatusBit2)) &
						(nb3 = ~(b3 = otherInits.nullAssignmentValueBit1)) &
						((nb4 = ~(b4 = otherInits.nullAssignmentValueBit2)) |
							((a2 = this.nullAssignmentStatusBit2) ^ 
								(a4 = this.nullAssignmentValueBit2))) | 
					nb4 & (na2 = ~a2) & (na4 = ~a4));
			this.nullAssignmentStatusBit2 =
				b1 & b2 |
				~b1 & (((na1 = ~a1) | a4) & b2 |
						a2 & (b2 |
							a1 & (na4 = ~a4) & nb2 & nb3 |
							(~(a3 = this.nullAssignmentValueBit1) & nb3 | na1 & na4) & nb4));
			this.nullAssignmentValueBit1 = 
				nb2 & b3 |
				~b1 & ((a1 & na2 & na4 | na1 & a3) & (nb2 | nb4) |
						a1 & na2 & a3 & nb2 |
						(a1 | a2 | na4) & b3);
			this.nullAssignmentValueBit2 =
				b4 |
				a4 & (nb2 & nb3 | ~(b1 ^ b2));
		}
		this.tagBits |= NULL_FLAG_MASK; // in all cases - avoid forgetting extras
	}
	// treating extra storage
	if (this.extra != null || otherInits.extra != null) {
		int mergeLimit = 0, copyLimit = 0;
		if (this.extra != null) {
			if (otherInits.extra != null) {
				// both sides have extra storage
				int length, otherLength;
				if ((length = this.extra[0].length) < 
						(otherLength = otherInits.extra[0].length)) {
					// current storage is shorter -> grow current (could maybe reuse otherInits extra storage?)
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0, 
							(this.extra[j] = new long[otherLength]), 0, length);
					System.arraycopy(extraDefiniteNonNulls, 0, (extraDefiniteNonNulls = new long[otherLength]), 0, length);					
					for (; i < length; i++) {
						extraDefiniteInits[i] |= otherInits.extraDefiniteInits[i];
						extraPotentialInits[i] |= otherInits.extraPotentialInits[i];
						extraDefiniteNulls[i] = (extraDefiniteNulls[i] | otherInits.extraDefiniteNulls[i]) & ~otherInits.extraDefiniteNonNulls[i];
						extraDefiniteNonNulls[i] = (extraDefiniteNonNulls[i] | otherInits.extraDefiniteNonNulls[i]) & ~otherInits.extraDefiniteNulls[i];
					}
					for (; i < otherLength; i++) {
						extraPotentialInits[i] = otherInits.extraPotentialInits[i];
					}
					mergeLimit = length;
					copyLimit = otherLength;
				} else {
					// current storage is longer
					mergeLimit = otherLength;
				}
			} 
		} 
		else if (otherInits.extra != null) {
			// no storage here, but other has extra storage.
			// shortcut regular copy because array copy is better
			int otherLength;
			this.extra = new long[extraLength][];
			System.arraycopy(otherInits.extra[0], 0, 
				(this.extra[0] = new long[otherLength = 
					otherInits.extra[0].length]), 0, otherLength);			
			System.arraycopy(otherInits.extra[1], 0, 
				(this.extra[1] = new long[otherLength]), 0, otherLength);
			if (considerNulls) {
				for (int j = 2; j < extraLength; j++) {
					System.arraycopy(otherInits.extra[j], 0, 
						(this.extra[j] = new long[otherLength]), 0, otherLength);
				}
			}
			else {
				for (int j = 2; j < extraLength; j++) {
					this.extra[j] = new long[otherLength];			
				}
			}
		}
		int i = 0;
		for (; i < mergeLimit; i++) {
			this.extra[0][i] |= otherInits.extra[0][i];
			this.extra[1][i] |= otherInits.extra[1][i];
			if (considerNulls) { // could consider pushing the test outside the loop
				if (this.extra[2][i] == 0 &&
						this.extra[3][i] == 0 &&
						this.extra[4][i] == 0 &&
						this.extra[5][i] == 0) {
					for (int j = 2; j < extraLength; j++) {
						this.extra[j][i] = otherInits.extra[j][i];
					}
				}
				else {
					this.extra[2][i] =
						(b1 = otherInits.extra[2][i]) |
						(a1	 = this.extra[2][i]) & 
							((nb2 = ~(b2 = otherInits.extra[3][i])) &
								(nb3 = ~(b3 = otherInits.extra[4][i])) &
								((nb4 = ~(b4 = otherInits.extra[5][i])) |
									((a2 = this.extra[3][i]) ^ 
										(a4 = this.extra[5][i]))) | 
							nb4 & (na2 = ~a2) & (na4 = ~a4));
					this.extra[3][i] =
						b1 & b2 |
						~b1 & (((na1 = ~a1) | a4) & b2 |
								a2 & (b2 |
									a1 & (na4 = ~a4) & nb2 & nb3 |
									(~(a3 = this.extra[4][i]) & nb3 | na1 & na4) & nb4));
					this.extra[4][i] = 
						nb2 & b3 |
						~b1 & ((a1 & na2 & na4 | na1 & a3) & (nb2 | nb4) |
								a1 & na2 & a3 & nb2 |
								(a1 | a2 | na4) & b3);
					this.extra[5][i] =
						b4 |
						a4 & (nb2 & nb3 | ~(b1 ^ b2));
				}
			}
		}
		for (; i < copyLimit; i++) {
			this.extra[0][i] = otherInits.extra[0][i];
			this.extra[1][i] = otherInits.extra[1][i];
			if (considerNulls) {
				for (int j = 2; j < extraLength; j++) {
					this.extra[j][i] = otherInits.extra[j][i];
				}
			}
		}
	}
	return this;
}

public FlowInfo addPotentialInitializationsFrom(FlowInfo inits) {
	if (this == DEAD_END){
		return this;
	}
	if (inits == DEAD_END){
		return this;
	}
	UnconditionalFlowInfo otherInits = inits.unconditionalInits();
	// union of potentially set ones
	this.potentialInits |= otherInits.potentialInits;
	// treating extra storage
	if (this.extra != null) {
		if (otherInits.extra != null) {
			// both sides have extra storage
			int i = 0, length, otherLength;
			if ((length = this.extra[0].length) < (otherLength = otherInits.extra[0].length)) {
				// current storage is shorter -> grow current
				for (int j = 0; j < extraLength; j++) {
					System.arraycopy(this.extra[j], 0, 
						(this.extra[j] = new long[otherLength]), 0, length);
				}
				for (; i < length; i++) {
					this.extra[1][i] |= otherInits.extra[1][i];
				}
				for (; i < otherLength; i++) {
					this.extra[1][i] = otherInits.extra[1][i];
				}
			} 
			else {
				// current storage is longer
				for (; i < otherLength; i++) {
					this.extra[1][i] |= otherInits.extra[1][i];
				}
			}
		}
	} 
	else if (otherInits.extra != null) {
		// no storage here, but other has extra storage.
		int otherLength = otherInits.extra[0].length;
		this.extra = new long[extraLength][];
		for (int j = 0; j < extraLength; j++) {
			this.extra[j] = new long[otherLength];			
		}
		System.arraycopy(otherInits.extra[1], 0, this.extra[1], 0, 
			otherLength);
	}
	this.addPotentialNullInfoFrom(otherInits);
	return this;
}

/**
 * Compose other inits over this flow info, then return this. The operation
 * semantics are to wave into this flow info the consequences upon null 
 * information of a possible path into the operations that resulted into 
 * otherInits. The fact that this path may be left unexecuted under peculiar 
 * conditions results into less specific results than 
 * {@link #addInitializationsFrom(FlowInfo) addInitializationsFrom}; moreover,
 * only the null information is affected.
 * @param otherInits other null inits to compose over this
 * @return this, modified according to otherInits information
 */
public UnconditionalFlowInfo addPotentialNullInfoFrom(
		UnconditionalFlowInfo otherInits) {
	if ((this.tagBits & UNREACHABLE) != 0 ||
			(otherInits.tagBits & UNREACHABLE) != 0 ||
			(otherInits.tagBits & NULL_FLAG_MASK) == 0) {
		return this;
	}
	// if we get here, otherInits has some null info
	boolean thisHasNulls = (this.tagBits & NULL_FLAG_MASK) != 0;
	if (thisHasNulls) {
		long a1, a2, na2, a3, na3, a4, na4, b1, nb1, b2, nb2, b3, nb3, b4, nb4;
		this.nullAssignmentStatusBit1 =
			((a1 = this.nullAssignmentStatusBit1) &
					(na4 = ~(a4 = this.nullAssignmentValueBit2)) &	
					((na3 = ~(a3 = this.nullAssignmentValueBit1)) | 
							(a2 = this.nullAssignmentStatusBit2)) | 
							a2 & na3 &	a4) & 
					(nb3 = ~(b3 = otherInits.nullAssignmentValueBit1)) &
					((b2 = otherInits.nullAssignmentStatusBit2) | 
					(nb4 = ~(b4 = otherInits.nullAssignmentValueBit2))) |
			a1 & (na2 = ~a2) & 
				(a4 & ((nb1 = ~(b1 = otherInits.nullAssignmentStatusBit1)) & 
						nb3 | b1 &
						(b4 | b2)) |
				na4 & (nb1 & (((nb2 = ~b2) & nb4 | b2) & nb3 | b3 & nb4) | 
						b1 & nb4 & (nb2 | nb3)));
		this.nullAssignmentStatusBit2 =
			a2 & (~a1 & na4 & nb4 |
					a1 & na3 & nb3 & (nb1 & (nb2 & nb4 | b2) |
										b1 & (nb4 |b2 & b4)));
		this.nullAssignmentValueBit1 =
			a3 |
			b1 & nb2 & nb4 |
			nb1 & b3 |
			a1 & na2 & (b1 & b3 | nb1 & b4);
//			b1 & (~b2 & ~b4 | a1 & ~a2 & b3) |
//			~b1 & (b3 | a1 & ~a2 & b4); -- same op nb
		this.nullAssignmentValueBit2 =
			a4 & (na2 | a2 & na3) |
			b4 & (nb2 | b2 & nb3);
		// extra storage management
		if (otherInits.extra != null) {
			int mergeLimit = 0, copyLimit = 0;
			int otherLength = otherInits.extra[0].length;
			if (this.extra == null) {
				this.extra = new long[extraLength][];
				for (int j = 0; j < extraLength; j++) {
					this.extra[j] = new long[otherLength];
				}
				copyLimit = otherLength;
			}
			else {
				mergeLimit = otherLength;
				if (mergeLimit > this.extra[0].length) {
					copyLimit = mergeLimit;
					mergeLimit = this.extra[0].length;
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
								this.extra[j] = new long[otherLength], 0,
								mergeLimit);
					}
				}
				int i;
				for (i = 0; i < mergeLimit; i++) {
					this.extra[2][i] =
						((a1 = this.extra[2][i]) &
								(na4 = ~(a4 = this.extra[5][i])) &	
								((na3 = ~(a3 = this.extra[4][i])) | 
										(a2 = this.extra[3][i])) | 
										a2 & na3 &	a4) & 
								(nb3 = ~(b3 = otherInits.extra[4][i])) &
								((b2 = otherInits.extra[3][i]) | 
								(nb4 = ~(b4 = otherInits.extra[5][i]))) |
						a1 & (na2 = ~a2) & 
							(a4 & ((nb1 = ~(b1 = otherInits.extra[2][i])) & 
									nb3 | b1 &
									(b4 | b2)) |
							na4 & (nb1 & (((nb2 = ~b2) & nb4 | b2) & nb3 | b3 & nb4) | 
									b1 & nb4 & (nb2 | nb3)));
					this.extra[3][i] =
						a2 & (~a1 & na4 & nb4 |
								a1 & na3 & nb3 & (nb1 & (nb2 & nb4 | b2) |
													b1 & (nb4 |b2 & b4)));
					this.extra[4][i] =
						a3 |
						b1 & nb2 & nb4 |
						nb1 & b3 |
						a1 & na2 & (b1 & b3 | nb1 & b4);
					this.extra[5][i] =
						a4 & (na2 | a2 & na3) |
						b4 & (nb2 | b2 & nb3);
				}
				for (; i < copyLimit; i++) {
					if (otherInits.extra[4][i] != 0 ||
						otherInits.extra[5][i] != 0) {
						this.tagBits |= NULL_FLAG_MASK; 
						this.extra[4][i] = 
							otherInits.extra[4][i] &
							~(otherInits.extra[2][i] &
							  ~otherInits.extra[3][i] &
							  otherInits.extra[5][i]);
						this.extra[5][i] = 
							otherInits.extra[5][i];
					}
				}
			}
		}
	}
	else {
		if (otherInits.nullAssignmentValueBit1 != 0 ||
			otherInits.nullAssignmentValueBit2 != 0) {
			// add potential values
			this.nullAssignmentValueBit1 = 
				otherInits.nullAssignmentValueBit1 & 
					~(otherInits.nullAssignmentStatusBit1 &
					  ~otherInits.nullAssignmentStatusBit2 &
					  otherInits.nullAssignmentValueBit2); // exclude assigned unknown
			this.nullAssignmentValueBit2 = 
				otherInits.nullAssignmentValueBit2;
			thisHasNulls = 
				this.nullAssignmentValueBit1 != 0 ||
				this.nullAssignmentValueBit2 != 0;
		}
		// extra storage management
		if (otherInits.extra != null) {
			int mergeLimit = 0, copyLimit = 0;
			int otherLength = otherInits.extra[0].length;
			if (this.extra == null) {
				copyLimit = otherLength; 
					// cannot happen when called from addPotentialInitializationsFrom
				this.extra = new long[extraLength][];
				for (int j = 0; j < extraLength; j++) {
					this.extra[j] = new long[otherLength];
				}
			}
			else {
				mergeLimit = otherLength;
				if (mergeLimit > this.extra[0].length) {
					copyLimit = mergeLimit;
					mergeLimit = this.extra[0].length;
					System.arraycopy(this.extra[0], 0,
							this.extra[0] = new long[otherLength], 0,
							mergeLimit);
					System.arraycopy(this.extra[1], 0,
							this.extra[1] = new long[otherLength], 0,
							mergeLimit);
					for (int j = 2; j < extraLength; j++) {
						this.extra[j] = new long[otherLength];
					}
				}
			}
			int i;
			for (i = 0; i < mergeLimit; i++) {
				if (otherInits.extra[4][i] != 0 ||
					otherInits.extra[5][i] != 0) {
					this.extra[4][i] |= 
						otherInits.extra[4][i] &
						~(otherInits.extra[2][i] &
						  ~otherInits.extra[3][i] &
						  otherInits.extra[5][i]);
					this.extra[5][i] |= 
						otherInits.extra[5][i];
					thisHasNulls = thisHasNulls ||
						this.extra[4][i] != 0 ||
						this.extra[5][i] != 0;
				}
			}
			for (; i < copyLimit; i++) {
				if (otherInits.extra[4][i] != 0 ||
					otherInits.extra[5][i] != 0) {
					this.extra[4][i] = 
						otherInits.extra[4][i] &
						~(otherInits.extra[2][i] &
						  ~otherInits.extra[3][i] &
						  otherInits.extra[5][i]);
					this.extra[5][i] = 
						otherInits.extra[5][i];
					thisHasNulls = thisHasNulls ||
						this.extra[4][i] != 0 ||
						this.extra[5][i] != 0;
				}
			}
		return this;
	}

	/**
	 * Answers a copy of the current instance
	 */
	public FlowInfo copy() {
		
		// do not clone the DeadEnd
		if (this == DEAD_END)
			return this;
	
		// look for an unused preallocated object
		UnconditionalFlowInfo copy = new UnconditionalFlowInfo();
	
		// copy slots
		copy.definiteInits = this.definiteInits;
		copy.potentialInits = this.potentialInits;
		copy.definiteNulls = this.definiteNulls;
		copy.definiteNonNulls = this.definiteNonNulls;
		copy.reachMode = this.reachMode;
		copy.maxFieldCount = this.maxFieldCount;
		
		if (this.extraDefiniteInits != null) {
			int length;
			System.arraycopy(this.extraDefiniteInits, 0, (copy.extraDefiniteInits = new long[length = extraDefiniteInits.length]), 0, length);
			System.arraycopy(this.extraPotentialInits, 0, (copy.extraPotentialInits = new long[length]), 0, length);
			System.arraycopy(this.extraDefiniteNulls, 0, (copy.extraDefiniteNulls = new long[length]), 0, length);
			System.arraycopy(this.extraDefiniteNonNulls, 0, (copy.extraDefiniteNonNulls = new long[length]), 0, length);
		}
		return copy;
	}
	if (thisHasNulls) {
		this.tagBits |= NULL_FLAG_MASK; 
	}
	else {
		this.tagBits &= NULL_FLAG_MASK; 
		if (limit < BitCacheSize) {
			long mask = (1L << limit)-1;
			this.definiteInits &= ~mask;
			this.potentialInits &= ~mask;
			this.definiteNulls &= ~mask;
			this.definiteNonNulls &= ~mask;
			return this;
		} 

		this.definiteInits = 0;
		this.potentialInits = 0;
		this.definiteNulls = 0;
		this.definiteNonNulls = 0;
		
		// use extra vector
		if (extraDefiniteInits == null) {
			return this; // if vector not yet allocated, then not initialized
		}
		int vectorIndex, length = this.extraDefiniteInits.length;
		if ((vectorIndex = (limit / BitCacheSize) - 1) >= length) {
			return this; // not enough room yet
		}
		for (int i = 0; i < vectorIndex; i++) {
			this.extraDefiniteInits[i] = 0L;
			this.extraPotentialInits[i] = 0L;
			this.extraDefiniteNulls[i] = 0L;
			this.extraDefiniteNonNulls[i] = 0L;
		}
		long mask = (1L << (limit % BitCacheSize))-1;
		this.extraDefiniteInits[vectorIndex] &= ~mask;
		this.extraPotentialInits[vectorIndex] &= ~mask;
		this.extraDefiniteNulls[vectorIndex] &= ~mask;
		this.extraDefiniteNonNulls[vectorIndex] &= ~mask;
		return this;
	}
	return this;
}

public FlowInfo copy() {
	// do not clone the DeadEnd
	if (this == DEAD_END) {
		
		if (limit < BitCacheSize) {
			long mask = (1L << limit)-1;
			this.definiteInits &= mask;
			this.potentialInits &= mask;
			this.definiteNulls &= mask;
			this.definiteNonNulls &= mask;
			return this;
		} 
		// use extra vector
		if (extraDefiniteInits == null) {
			return this; // if vector not yet allocated, then not initialized
		}
		int vectorIndex, length = this.extraDefiniteInits.length;
		if ((vectorIndex = (limit / BitCacheSize) - 1) >= length) {
			return this; // not enough room yet
		}
		long mask = (1L << (limit % BitCacheSize))-1;
		this.extraDefiniteInits[vectorIndex] &= mask;
		this.extraPotentialInits[vectorIndex] &= mask;
		this.extraDefiniteNulls[vectorIndex] &= mask;
		this.extraDefiniteNonNulls[vectorIndex] &= mask;
		for (int i = vectorIndex+1; i < length; i++) {
			this.extraDefiniteInits[i] = 0L;
			this.extraPotentialInits[i] = 0L;
			this.extraDefiniteNulls[i] = 0L;
			this.extraDefiniteNonNulls[i] = 0L;
		}
		return this;
	}
	UnconditionalFlowInfo copy = new UnconditionalFlowInfo();
	// copy slots
	copy.definiteInits = this.definiteInits;
	copy.potentialInits = this.potentialInits;
	boolean hasNullInfo = (this.tagBits & NULL_FLAG_MASK) != 0;
	if (hasNullInfo) { 
		copy.nullAssignmentStatusBit1 = this.nullAssignmentStatusBit1;
		copy.nullAssignmentStatusBit2 = this.nullAssignmentStatusBit2;
		copy.nullAssignmentValueBit1 = this.nullAssignmentValueBit1;
		copy.nullAssignmentValueBit2 = this.nullAssignmentValueBit2;
	}
	copy.tagBits = this.tagBits;
	copy.maxFieldCount = this.maxFieldCount;
	if (this.extra != null) {
		int length;
		copy.extra = new long[extraLength][];
		System.arraycopy(this.extra[0], 0, 
			(copy.extra[0] = new long[length = this.extra[0].length]), 0, 
			length);
		System.arraycopy(this.extra[1], 0, 
			(copy.extra[1] = new long[length]), 0, length);
		if (hasNullInfo) {
			for (int j = 2; j < extraLength; j++) {
				System.arraycopy(this.extra[j], 0, 
					(copy.extra[j] = new long[length]), 0, length);
			}
		}
		else {
			for (int j = 2; j < extraLength; j++) {
				copy.extra[j] = new long[length];
			}
		}
		return this;
	}
	return copy;
}

/**
 * Remove local variables information from this flow info and return this.
 * @return this, deprived from any local variable information
 */
public UnconditionalFlowInfo discardNonFieldInitializations() {
	int limit = this.maxFieldCount;
	if (limit < BitCacheSize) {
		long mask = (1L << limit)-1;
		this.definiteInits &= mask;
		this.potentialInits &= mask;
		this.nullAssignmentStatusBit1 &= mask;
		this.nullAssignmentStatusBit2 &= mask;
		this.nullAssignmentValueBit1 &= mask;
		this.nullAssignmentValueBit2 &= mask;
	} 
	// use extra vector
	if (this.extra == null) {
		return this; // if vector not yet allocated, then not initialized
	}
	int vectorIndex, length = this.extra[0].length;
	if ((vectorIndex = (limit / BitCacheSize) - 1) >= length) {
		return this; // not enough room yet
	}
	if (vectorIndex >= 0) { 
		// else we only have complete non field array items left
		long mask = (1L << (limit % BitCacheSize))-1;
		for (int j = 0; j < extraLength; j++) {
			this.extra[j][vectorIndex] &= mask;
	 */
	final private boolean isDefinitelyAssigned(int position) {
		
		// Dependant of CodeStream.isDefinitelyAssigned(..)
		// id is zero-based
		if (position < BitCacheSize) {
			return (definiteInits & (1L << position)) != 0; // use bits
		}
		// use extra vector
		if (extraDefiniteInits == null)
			return false; // if vector not yet allocated, then not initialized
		int vectorIndex;
		if ((vectorIndex = (position / BitCacheSize) - 1) >= extraDefiniteInits.length)
			return false; // if not enough room in vector, then not initialized 
		return ((extraDefiniteInits[vectorIndex]) & (1L << (position % BitCacheSize))) != 0;
	}
	for (int i = vectorIndex + 1; i < length; i++) {
		for (int j = 0; j < extraLength; j++) {
			this.extra[j][i] = 0;
	 * It deals with the dual representation of the InitializationInfo2:
	 * bits for the first 64 entries, then an array of booleans.
	 */
	final private boolean isDefinitelyNonNull(int position) {
		
		// Dependant of CodeStream.isDefinitelyAssigned(..)
		// id is zero-based
		if (position < BitCacheSize) {
			return (definiteNonNulls & (1L << position)) != 0; // use bits
		}
		// use extra vector
		if (extraDefiniteNonNulls == null)
			return false; // if vector not yet allocated, then not initialized
		int vectorIndex;
		if ((vectorIndex = (position / BitCacheSize) - 1) >= extraDefiniteNonNulls.length)
			return false; // if not enough room in vector, then not initialized 
		return ((extraDefiniteNonNulls[vectorIndex]) & (1L << (position % BitCacheSize))) != 0;
	}

	/**
	 * Check status of definite null assignment at a given position.
	 * It deals with the dual representation of the InitializationInfo2:
	 * bits for the first 64 entries, then an array of booleans.
	 */
	final private boolean isDefinitelyNull(int position) {
		
		// Dependant of CodeStream.isDefinitelyAssigned(..)
		// id is zero-based
		if (position < BitCacheSize) {
			return (definiteNulls & (1L << position)) != 0; // use bits
		}
		// use extra vector
		if (extraDefiniteNulls == null)
			return false; // if vector not yet allocated, then not initialized
		int vectorIndex;
		if ((vectorIndex = (position / BitCacheSize) - 1) >= extraDefiniteNulls.length)
			return false; // if not enough room in vector, then not initialized 
		return ((extraDefiniteNulls[vectorIndex]) & (1L << (position % BitCacheSize))) != 0;
	}

	/**
	 * Check status of definite assignment for a field.
	 */
	final public boolean isDefinitelyAssigned(FieldBinding field) {
		
		// Dependant of CodeStream.isDefinitelyAssigned(..)
		// We do not want to complain in unreachable code
		if ((this.reachMode & UNREACHABLE) != 0)  
			return true;
		return isDefinitelyAssigned(field.id); 
	}
	return this;
}

public FlowInfo initsWhenFalse() {
	return this;
}

public FlowInfo initsWhenTrue() {
	return this;
}

/**
 * Check status of definite assignment at a given position.
 * It deals with the dual representation of the InitializationInfo2:
 * bits for the first 64 entries, then an array of booleans.
 */
final private boolean isDefinitelyAssigned(int position) {
	if (position < BitCacheSize) {
		// use bits
		return (this.definiteInits & (1L << position)) != 0; 
	}
	// use extra vector
	if (this.extra == null)
		return false; // if vector not yet allocated, then not initialized
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) 
			>= this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return ((this.extra[0][vectorIndex]) & 
				(1L << (position % BitCacheSize))) != 0;
}

final public boolean isDefinitelyAssigned(FieldBinding field) {
	// Dependant of CodeStream.isDefinitelyAssigned(..) 
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0) { 
		return true;
			return false;
		return isDefinitelyNonNull(field.id); 
	}
	return isDefinitelyAssigned(field.id); 
}

final public boolean isDefinitelyAssigned(LocalVariableBinding local) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0) {
		return true;
	}
	// final constants are inlined, and thus considered as always initialized
	if (local.constant() != Constant.NotAConstant) {
		return true;
		if (local.constant() != Constant.NotAConstant) {
			return true;
		}
		return isDefinitelyNonNull(local.id + maxFieldCount);
	}

	/**
	 * Check status of definite null assignment for a field.
	 */
	final public boolean isDefinitelyNull(FieldBinding field) {
		
		// Dependant of CodeStream.isDefinitelyAssigned(..)
		// We do not want to complain in unreachable code
		if ((this.reachMode & UNREACHABLE) != 0)  
			return false;
		return isDefinitelyNull(field.id); 
	}
	return isDefinitelyAssigned(local.id + this.maxFieldCount);
}

final public boolean isDefinitelyNonNull(LocalVariableBinding local) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 || 
			(this.tagBits & NULL_FLAG_MASK) == 0) {
		return false;
	}
	if ((local.type.tagBits & TagBits.IsBaseType) != 0 || 
			local.constant() != Constant.NotAConstant) { 
		return true;
	}
	int position = local.id + this.maxFieldCount;
	long mask;
	if (position < BitCacheSize) { // use bits
		return 
			(this.nullAssignmentStatusBit2 & 
				(mask = 1L << position)) != 0 ?
			(this.nullAssignmentStatusBit1 & mask) != 0 :
			(this.nullAssignmentStatusBit1 & 
				this.nullAssignmentValueBit2 & mask) != 0 &&
			(this.nullAssignmentValueBit1 & mask) == 0; 
	}
	// use extra vector
	if (this.extra == null) {
		return false; // if vector not yet allocated, then not initialized
	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1)  
			>= this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return 
		(this.extra[3][vectorIndex] & 
			(mask = 1L << (position % BitCacheSize))) != 0 ?
		(this.extra[2][vectorIndex] & mask) != 0 :
		(this.extra[2][vectorIndex] & 
			this.extra[5][vectorIndex] & mask) != 0 &&
		(this.extra[4][vectorIndex] & mask) == 0;
}

final public boolean isDefinitelyNull(LocalVariableBinding local) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 || 
			(this.tagBits & NULL_FLAG_MASK) == 0 || 
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = local.id + this.maxFieldCount;
	long mask;
	if (position < BitCacheSize) { // use bits
		return 
			(this.nullAssignmentStatusBit2 & (mask = 1L << position)) != 0 ?
			(this.nullAssignmentStatusBit1 & mask) == 0 :
			(this.nullAssignmentStatusBit1 & 
				this.nullAssignmentValueBit1 & mask) != 0 &&
			(this.nullAssignmentValueBit2 & mask) == 0; 
	}
	// use extra vector
	if (this.extra == null) {
		return false; // if vector not yet allocated, then not initialized
	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >= 
			this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return
		(this.extra[3][vectorIndex] & 
			(mask = 1L << (position % BitCacheSize))) != 0 ?
		(this.extra[2][vectorIndex] & mask) == 0 :
		(this.extra[2][vectorIndex] & 
			this.extra[4][vectorIndex] & mask) != 0 &&
		(this.extra[5][vectorIndex] & mask) == 0;
}

final public boolean isDefinitelyUnknown(LocalVariableBinding local) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 || 
			(this.tagBits & NULL_FLAG_MASK) == 0) {
		return false;
	}
	int position = local.id + this.maxFieldCount;
	long mask;
	if (position < BitCacheSize) { // use bits
		return 
			(this.nullAssignmentStatusBit2 & (mask = 1L << position)) != 0 ?
			false :
			(this.nullAssignmentStatusBit1 & 
				this.nullAssignmentValueBit1 & 
				this.nullAssignmentValueBit2 & mask) != 0; 
	}
	// use extra vector
	if (this.extra == null) {
		return false; // if vector not yet allocated, then not initialized
	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >= 
			this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return
		(this.extra[3][vectorIndex] & 
			(mask = 1L << (position % BitCacheSize))) != 0 ?
		false :
		(this.extra[2][vectorIndex] & 
			this.extra[4][vectorIndex] &
			this.extra[5][vectorIndex] &
			mask) != 0;
}

/**
 * Check status of potential assignment at a given position.
 * It deals with the dual representation of the InitializationInfo3:
 * bits for the first 64 entries, then an array of booleans.
 */
final private boolean isPotentiallyAssigned(int position) {
	// id is zero-based
	if (position < BitCacheSize) {
		// use bits
		return (this.potentialInits & (1L << position)) != 0;
	}
	// use extra vector
	if (this.extra == null) {
		return false; // if vector not yet allocated, then not initialized
	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) 
			>= this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return ((this.extra[1][vectorIndex]) & 
			(1L << (position % BitCacheSize))) != 0;
}

/**
 * Check status of definite assignment for a field.
 */
final public boolean isPotentiallyAssigned(FieldBinding field) {
	return isPotentiallyAssigned(field.id); 
}

/**
 * Check status of potential assignment for a local.
 */
final public boolean isPotentiallyAssigned(LocalVariableBinding local) {
	// final constants are inlined, and thus considered as always initialized
	if (local.constant() != Constant.NotAConstant) {
		return true;
	}
	return isPotentiallyAssigned(local.id + this.maxFieldCount);
}

final public boolean isPotentiallyNull(LocalVariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 || 
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	long mask;
	if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
		// use bits
		return
			(this.nullAssignmentStatusBit2 & (mask = 1L << position)) != 0 ?
			(this.nullAssignmentStatusBit1 & mask) == 0 : // protected null
			(this.nullAssignmentValueBit1 & mask) != 0 && // null bit set and
				((this.nullAssignmentStatusBit1 & mask) == 0 || // (potential or
				 (this.nullAssignmentValueBit2 & mask) == 0); 
											// assigned, but not unknown)
	}
	// use extra vector
	if (this.extra == null) {
		return false; // if vector not yet allocated, then not initialized
	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >= 
			this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return 
		(this.extra[3][vectorIndex] & 
			(mask = 1L << (position % BitCacheSize))) != 0 ?
		(this.extra[2][vectorIndex] & mask) == 0 :
		(this.extra[4][vectorIndex] & mask) != 0 && 
			((this.extra[2][vectorIndex] & mask) == 0 || 
			 (this.extra[5][vectorIndex] & mask) == 0); 
}

final public boolean isPotentiallyUnknown(LocalVariableBinding local) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 || 
			(this.tagBits & NULL_FLAG_MASK) == 0) {
		return false;
	}
	int position = local.id + this.maxFieldCount;
	long mask;
	if (position < BitCacheSize) { // use bits
		return 
			(this.nullAssignmentStatusBit2 & (mask = 1L << position)) != 0 ?
			false :
			((this.nullAssignmentStatusBit1 & 
				this.nullAssignmentValueBit1 |
			 ~this.nullAssignmentStatusBit1 &
				~this.nullAssignmentValueBit1) & 
				this.nullAssignmentValueBit2 & mask) != 0; 
	}
	// use extra vector
	if (this.extra == null) {
		return false; // if vector not yet allocated, then not initialized
	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >= 
			this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return
		(this.extra[3][vectorIndex] & 
			(mask = 1L << (position % BitCacheSize))) != 0 ?
		false :
		((this.extra[2][vectorIndex] & 
			this.extra[4][vectorIndex] |
		  ~this.extra[2][vectorIndex] &
			~this.extra[4][vectorIndex]) &
			this.extra[5][vectorIndex] &
			mask) != 0;
}

final public boolean isProtectedNonNull(LocalVariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
		// use bits
		return (this.nullAssignmentStatusBit1 &
				this.nullAssignmentStatusBit2 & (1L << position)) != 0;
	}
	// use extra vector
	if (this.extra == null) {
		return false; // if vector not yet allocated, then not initialized
	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >= 
		this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return (this.extra[4][vectorIndex] & 
			this.extra[5][vectorIndex] & 
			(1L << (position % BitCacheSize))) != 0;
}

final public boolean isProtectedNull(LocalVariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 || 
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
		// use bits
		return (~this.nullAssignmentStatusBit1 &
				this.nullAssignmentStatusBit2 & (1L << position)) != 0;
	}
	// use extra vector
	if (this.extra == null) {
		return false; // if vector not yet allocated, then not initialized
	}
	int vectorIndex;
	if ((vectorIndex = (position / BitCacheSize) - 1) >= 
			this.extra[0].length) {
		return false; // if not enough room in vector, then not initialized
	}
	return (~this.extra[4][vectorIndex] & 
			this.extra[5][vectorIndex] &
			(1L << (position % BitCacheSize))) != 0;
}

public void markAsComparedEqualToNonNull(LocalVariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		int position;
		long mask;
		// position is zero-based
		if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
			// use bits
			if (((mask = 1L << position) & // leave assigned non null unchanged 
					this.nullAssignmentStatusBit1 &
					~this.nullAssignmentStatusBit2 &
					~this.nullAssignmentValueBit1 &
					this.nullAssignmentValueBit2) == 0) {
				// set protected non null
				this.nullAssignmentStatusBit1 |= mask;
				this.nullAssignmentStatusBit2 |= mask;
				 // clear potential null
				this.nullAssignmentValueBit1 &= ~mask;
			}
		} 
		else {
			// use extra vector
			int vectorIndex = (position / BitCacheSize) - 1;
			if (this.extra == null) {
				int length = vectorIndex + 1;
				this.extra = new long[extraLength][];
				for (int j = 0; j < extraLength; j++) {
					this.extra[j] = new long[length];
				}
			}
			else {
				int oldLength;
				if (vectorIndex >= (oldLength = this.extra[0].length)) {
					int newLength = vectorIndex + 1;
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0, 
							(this.extra[j] = new long[newLength]), 0, 
							oldLength);
					}
				}
			}
			if (((mask = 1L << (position % BitCacheSize)) & 
					this.extra[2][vectorIndex] &
					~this.extra[3][vectorIndex] &
					~this.extra[4][vectorIndex] &
					this.extra[5][vectorIndex]) == 0) {
				this.extra[2][vectorIndex] |= mask;
				this.extra[3][vectorIndex] |= mask;
				this.extra[4][vectorIndex] &= ~mask;
			}
		}
		// use extra vector
		if (extraPotentialInits == null)
			return false; // if vector not yet allocated, then not initialized
		int vectorIndex;
		if ((vectorIndex = (position / BitCacheSize) - 1) >= extraPotentialInits.length)
			return false; // if not enough room in vector, then not initialized 
		return ((extraPotentialInits[vectorIndex]) & (1L << (position % BitCacheSize))) != 0;
	}
	
	/**
	 * Check status of definite assignment for a field.
	 */
	final public boolean isPotentiallyAssigned(FieldBinding field) {
		
		return isPotentiallyAssigned(field.id); 
	}
}

public void markAsComparedEqualToNull(LocalVariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		int position;
		long mask, unknownAssigned;
		// position is zero-based
		if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
			// use bits
			mask = 1L << position;
			if ((mask & // leave assigned null unchanged
					this.nullAssignmentStatusBit1 &
					~this.nullAssignmentStatusBit2 &
					this.nullAssignmentValueBit1 &
					~this.nullAssignmentValueBit2) == 0) {
				unknownAssigned = this.nullAssignmentStatusBit1 &
					~this.nullAssignmentStatusBit2 &
					this.nullAssignmentValueBit1 &
					this.nullAssignmentValueBit2;
				// set protected
				this.nullAssignmentStatusBit2 |= mask;
				this.nullAssignmentStatusBit1 &= (mask = ~mask);
				// protected is null
				this.nullAssignmentValueBit1 &= mask | ~unknownAssigned;
				this.nullAssignmentValueBit2 &= mask;
				// clear potential anything but null
			}
		} 
		else {
			// use extra vector
			int vectorIndex = (position / BitCacheSize) - 1;
			mask = 1L << (position % BitCacheSize);
			if (this.extra == null) {
				int length = vectorIndex + 1;
				this.extra = new long[extraLength][];
				for (int j = 0; j < extraLength; j++) {
					this.extra[j] = new long[length ];
				}
			}
			else {
				int oldLength;
				if (vectorIndex >= (oldLength = this.extra[0].length)) {
					int newLength = vectorIndex + 1;
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0, 
							(this.extra[j] = new long[newLength]), 0,
							oldLength);
					}
				}
			}
			if ((mask &
					this.extra[2][vectorIndex] &
					~this.extra[3][vectorIndex] &
					this.extra[4][vectorIndex] &
					~this.extra[5][vectorIndex]) == 0) {
				unknownAssigned = this.extra[2][vectorIndex] &
					~this.extra[3][vectorIndex] &
					this.extra[4][vectorIndex] &
					this.extra[5][vectorIndex];
				this.extra[3][vectorIndex]	 |= mask;
				this.extra[2][vectorIndex] &= (mask = ~mask);
				this.extra[4][vectorIndex] &= mask | ~unknownAssigned;
				this.extra[5][vectorIndex]	&= mask;
			}
		}
		return isPotentiallyAssigned(local.id + maxFieldCount);
	}
}

/**
 * Record a definite assignment at a given position.
 * It deals with the dual representation of the InitializationInfo2:
 * bits for the first 64 entries, then an array of booleans.
 */
final private void markAsDefinitelyAssigned(int position) {
	
	if (this != DEAD_END) {
		// position is zero-based
		if (position < BitCacheSize) {
			// use bits
			long mask;
			this.definiteInits |= (mask = 1L << position);
			this.potentialInits |= mask;
		} 
		else {
			// use extra vector
			int vectorIndex = (position / BitCacheSize) - 1;
			if (this.extra == null) {
				int length = vectorIndex + 1;
				this.extra = new long[extraLength][];
				for (int j = 0; j < extraLength; j++) {
					this.extra[j] = new long[length];
				}
			} 
			else {
				int oldLength; // might need to grow the arrays
				if (vectorIndex >= (oldLength = this.extra[0].length)) {
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0, 
							(this.extra[j] = new long[vectorIndex + 1]), 0, 
							oldLength);
					extraDefiniteNonNulls = new long[length];
				} else {
					int oldLength; // might need to grow the arrays
					if (vectorIndex >= (oldLength = extraDefiniteInits.length)) {
						System.arraycopy(extraDefiniteInits, 0, (extraDefiniteInits = new long[vectorIndex + 1]), 0, oldLength);
						System.arraycopy(extraPotentialInits, 0, (extraPotentialInits = new long[vectorIndex + 1]), 0, oldLength);
						System.arraycopy(extraDefiniteNulls, 0, (extraDefiniteNulls = new long[vectorIndex + 1]), 0, oldLength);
						System.arraycopy(extraDefiniteNonNulls, 0, (extraDefiniteNonNulls = new long[vectorIndex + 1]), 0, oldLength);
					}
				}
				long mask;
				extraDefiniteInits[vectorIndex] |= (mask = 1L << (position % BitCacheSize));
				extraPotentialInits[vectorIndex] |= mask;
				extraDefiniteNulls[vectorIndex] &= ~mask;
				extraDefiniteNonNulls[vectorIndex] &= ~mask;
			}
			long mask;
			this.extra[0][vectorIndex] |= 
				(mask = 1L << (position % BitCacheSize));
			this.extra[1][vectorIndex] |= mask;
		}
	}
}

public void markAsDefinitelyAssigned(FieldBinding field) {
	if (this != DEAD_END)
		markAsDefinitelyAssigned(field.id);
}

public void markAsDefinitelyAssigned(LocalVariableBinding local) {
	if (this != DEAD_END)
		markAsDefinitelyAssigned(local.id + this.maxFieldCount);
}

/**
 * Record a definite non-null assignment at a given position.
 */
final private void markAsDefinitelyNonNull(int position) {
	// DEAD_END guarded above
	this.tagBits |= NULL_FLAG_MASK;
	long mask;
	// position is zero-based
	if (position < BitCacheSize) {
		// use bits
		this.nullAssignmentStatusBit1 |= (mask = 1L << position);
		this.nullAssignmentValueBit2 |= mask; // set non null
		this.nullAssignmentStatusBit2 &= ~mask; // clear protection
		this.nullAssignmentValueBit1 &= ~mask; // clear null
	} 
	else {
		// use extra vector
		int vectorIndex = (position / BitCacheSize) - 1;
		this.extra[2][vectorIndex] |= 
			(mask = 1L << (position % BitCacheSize));
		this.extra[5][vectorIndex] |= mask;
		this.extra[3][vectorIndex] &= ~mask;
		this.extra[4][vectorIndex] &= ~mask;
	}
}

public void markAsDefinitelyNonNull(FieldBinding field) {
	if (this != DEAD_END) {
		markAsDefinitelyNonNull(field.id);
		if (this != DEAD_END)
			markAsDefinitelyAssigned(local.id + maxFieldCount);
	}

	/**
	 * Record a definite non-null assignment at a given position.
	 * It deals with the dual representation of the InitializationInfo2:
	 * bits for the first 64 entries, then an array of booleans.
	 */
	final private void markAsDefinitelyNonNull(int position) {
		
		if (this != DEAD_END) {
	
			// position is zero-based
			if (position < BitCacheSize) {
				// use bits
				long mask;
				definiteNonNulls |= (mask = 1L << position);
				definiteNulls &= ~mask;
			} else {
				// use extra vector
				int vectorIndex = (position / BitCacheSize) - 1;
				long mask;
				extraDefiniteNonNulls[vectorIndex] |= (mask = 1L << (position % BitCacheSize));
				extraDefiniteNulls[vectorIndex] &= ~mask;
			}
		}
	}
}

public void markAsDefinitelyNonNull(LocalVariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		markAsDefinitelyNonNull(local.id + this.maxFieldCount);
		if (this != DEAD_END)
			markAsDefinitelyNonNull(field.id);
	}
}

/**
 * Record a definite null assignment at a given position.
 */
final private void markAsDefinitelyNull(int position) {
	// DEAD_END guarded above
	this.tagBits |= NULL_FLAG_MASK;
	long mask;
	if (position < BitCacheSize) {
		// use bits
		this.nullAssignmentStatusBit1 |= (mask = 1L << position); // set assignment
		this.nullAssignmentStatusBit2 &= ~mask; // clear protection
		this.nullAssignmentValueBit1 |= mask; // set null
		this.nullAssignmentValueBit2 &= ~mask; // clear non null
	} 
	else {
		// use extra vector
		int vectorIndex = (position / BitCacheSize) - 1;
		this.extra[2][vectorIndex] |= 
			(mask = 1L << (position % BitCacheSize));
		this.extra[3][vectorIndex] &= ~mask;
		this.extra[4][vectorIndex] |= mask;
		this.extra[5][vectorIndex] &= ~mask;
			} else {
				// use extra vector
				int vectorIndex = (position / BitCacheSize) - 1;
				long mask;
				extraDefiniteNulls[vectorIndex] |= (mask = 1L << (position % BitCacheSize));
				extraDefiniteNonNulls[vectorIndex] &= ~mask;
			}
		}
	}
}

public void markAsDefinitelyNull(FieldBinding field) {
	if (this != DEAD_END) {
		markAsDefinitelyNull(field.id);
	public void markAsDefinitelyNull(FieldBinding field) {
		if (this != DEAD_END)
			markAsDefinitelyAssigned(field.id);
	}
}

public void markAsDefinitelyNull(LocalVariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		markAsDefinitelyNull(local.id + this.maxFieldCount);
			markAsDefinitelyNull(local.id + maxFieldCount);
	}
}

/**
 * Mark a local as having been assigned to an unknown value.
 * @param local the local to mark
 */
// PREMATURE may try to get closer to markAsDefinitelyAssigned, but not
//			 obvious
public void markAsDefinitelyUnknown(LocalVariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		long mask;
		int position;
		// position is zero-based
		if ((position = local.id + this.maxFieldCount) < BitCacheSize) {
			// use bits
			this.nullAssignmentValueBit1 |= (mask = 1L << position);
			this.nullAssignmentValueBit2 |= mask;
			// set unknown
			this.nullAssignmentStatusBit1 |= mask;
			// set assignment
			this.nullAssignmentStatusBit2 &= ~mask;
			// clear protection
		} 
		else {
			// use extra vector
			int vectorIndex = (position / BitCacheSize) - 1;
			this.extra[4][vectorIndex] |=
				(mask = 1L << (position % BitCacheSize));
			this.extra[5][vectorIndex] |= mask;
			this.extra[2][vectorIndex] |= mask;
			this.extra[3][vectorIndex] &= ~mask;
		}
	}
}

public UnconditionalFlowInfo mergedWith(UnconditionalFlowInfo otherInits) {
	if ((otherInits.tagBits & UNREACHABLE) != 0 && this != DEAD_END) {
		// DEAD_END + unreachable other -> other
		return this;
		if (this != DEAD_END)
			markAsDefinitelyNotAssigned(field.id);
	}
	if ((this.tagBits & UNREACHABLE) != 0) {
		return (UnconditionalFlowInfo) otherInits.copy(); // make sure otherInits won't be affected
	} 
	
	// intersection of definitely assigned variables, 
	this.definiteInits &= otherInits.definiteInits;
	// union of potentially set ones
	this.potentialInits |= otherInits.potentialInits;

	// null combinations
	boolean otherHasNulls = (otherInits.tagBits & NULL_FLAG_MASK) != 0,
		thisHasNulls = false;
	long a1, a2, na2, a3, na3, a4, na4, b1, nb1, b2, nb2, b3, nb3, b4, nb4;
	if (otherHasNulls) {
		this.nullAssignmentStatusBit1 =
			(a1 = this.nullAssignmentStatusBit1) & 
			(b1 = otherInits.nullAssignmentStatusBit1) & (
				(nb4 = ~(b4 = otherInits.nullAssignmentValueBit2)) & 
				((b2 = otherInits.nullAssignmentStatusBit2) & 
						(nb3 = ~(b3 = otherInits.nullAssignmentValueBit1)) & 
						(na3 = ~(a3 = this.nullAssignmentValueBit1)) & 
						((a2 = this.nullAssignmentStatusBit2) & 
							(na4 = ~(a4 = this.nullAssignmentValueBit2)) | a4) |
						(na2 = ~a2) & a3 & na4 & (nb2 = ~b2) & b3 ) |
				b4 & (na3 & nb3 & (na4 & a2 | a4) |
						na2 & a4 & nb2));
		this.nullAssignmentStatusBit2 =
			a2 & b2 & ~(a1 ^ b1) & (na3 & nb3 | na4 & nb4) |
			a1 & b1 & (a2 ^ b2) & na3 & nb3 |
			(a1 & na2 & (nb1 = ~b1) & b2 | ~a1 & a2 & b1 & nb2) & na4 & nb4;
		this.nullAssignmentValueBit1 =
			b1 & nb2 & nb4 |
			~a1 & (a3 |
					a2 & na3 & (b1 | nb2)) |
			(a1 | na2) & nb1 & b2 & nb3 |
			nb1 & b3 |
			a1 & na2 & (na4 |
						b1 & nb2 & (a3 | b3));
		this.nullAssignmentValueBit2 =
			a4 | b4;
	}
	else {
		// tune potentials
		this.nullAssignmentValueBit1 =
			~(~this.nullAssignmentStatusBit1 &
					~this.nullAssignmentStatusBit2 &
					~this.nullAssignmentValueBit1) &
			~(this.nullAssignmentStatusBit1 & 
					(this.nullAssignmentStatusBit2 | this.nullAssignmentValueBit2));
		// reset assignment and protected
		this.nullAssignmentStatusBit1 = 
		this.nullAssignmentStatusBit2 = 0;
	}
	thisHasNulls = this.nullAssignmentStatusBit1 != 0 || 
		this.nullAssignmentStatusBit2 != 0 ||
		this.nullAssignmentValueBit1 != 0 ||
		this.nullAssignmentValueBit2 != 0;

	// treating extra storage
	if (this.extra != null || otherInits.extra != null) {
		int mergeLimit = 0, copyLimit = 0, resetLimit = 0;
		if (this.extra != null) {
			if (otherInits.extra != null) {
				// both sides have extra storage
				int length, otherLength;
				if ((length = this.extra[0].length) < 
						(otherLength = otherInits.extra[0].length)) {
					// current storage is shorter -> grow current 
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0, 
							(this.extra[j] = new long[otherLength]), 0, length);
					while (i < length) {
						this.extraDefiniteInits[i] &= otherInits.extraDefiniteInits[i];
						this.extraPotentialInits[i] |= otherInits.extraPotentialInits[i];
						this.extraDefiniteNulls[i] &= otherInits.extraDefiniteNulls[i];
						this.extraDefiniteNonNulls[i] &= otherInits.extraDefiniteNonNulls[i++];
					}
					mergeLimit = length;
					copyLimit = otherLength;
				} 
				else {
					// current storage is longer
					mergeLimit = otherLength;
					resetLimit = length;
						this.extraPotentialInits[i] |= otherInits.extraPotentialInits[i];
						this.extraDefiniteNulls[i] &= otherInits.extraDefiniteNulls[i];
						this.extraDefiniteNonNulls[i] &= otherInits.extraDefiniteNonNulls[i++];
					}
					while (i < length) {
						this.extraDefiniteInits[i] = 0;
						this.extraDefiniteNulls[i] = 0;
						this.extraDefiniteNonNulls[i++] = 0;
					}
				}
			} 
			else {
				resetLimit = this.extra[0].length;
				while (i < length) {
					this.extraDefiniteInits[i] = 0;
					this.extraDefiniteNulls[i] = 0;
					this.extraDefiniteNonNulls[i++] = 0;
				}
			}
		} else
			if (otherInits.extraDefiniteInits != null) {
				// no storage here, but other has extra storage.
				int otherLength;
				this.extraDefiniteInits = new long[otherLength = otherInits.extraDefiniteInits.length];
				System.arraycopy(otherInits.extraPotentialInits, 0, (this.extraPotentialInits = new long[otherLength]), 0, otherLength);
				this.extraDefiniteNulls = new long[otherLength];
				this.extraDefiniteNonNulls = new long[otherLength];
			}
		} 
		else if (otherInits.extra != null) {
			// no storage here, but other has extra storage.
			int otherLength = otherInits.extra[0].length;
			this.extra = new long[extraLength][];
			for (int j = 0; j < extraLength; j++) {
				this.extra[j] = new long[otherLength];
			}
			System.arraycopy(otherInits.extra[1], 0, 
				this.extra[1], 0, otherLength);
			copyLimit = otherLength;
		}
		int i;
		if (otherHasNulls) {
			for (i = 0; i < mergeLimit; i++) {
				this.extra[2][i] =
					(a1 = this.extra[2][i]) & 
					(b1 = otherInits.extra[2][i]) & (
						(nb4 = ~(b4 = otherInits.extra[5][i])) & 
						((b2 = otherInits.extra[3][i]) & 
								(nb3 = ~(b3 = otherInits.extra[4][i])) & 
								(na3 = ~(a3 = this.extra[4][i])) & 
								((a2 = this.extra[3][i]) & 
									(na4 = ~(a4 = this.extra[5][i])) | a4) |
								(na2 = ~a2) & a3 & na4 & (nb2 = ~b2) & b3 ) |
						b4 & (na3 & nb3 & (na4 & a2 | a4) |
								na2 & a4 & nb2));
				this.extra[3][i] =
					a2 & b2 & ~(a1 ^ b1) & (na3 & nb3 | na4 & nb4) |
					a1 & b1 & (a2 ^ b2) & na3 & nb3 |
					(a1 & na2 & (nb1 = ~b1) & b2 | ~a1 & a2 & b1 & nb2) & na4 & nb4;
				this.extra[4][i] =
					b1 & nb2 & nb4 |
					~a1 & (a3 |
							a2 & na3 & (b1 | nb2)) |
					(a1 | na2) & nb1 & b2 & nb3 |
					nb1 & b3 |
					a1 & na2 & (na4 |
								b1 & nb2 & (a3 | b3));
				this.extra[5][i] =
					a4 | b4;
				thisHasNulls = thisHasNulls ||
					this.extra[5][i] != 0 ||
					this.extra[2][i] != 0 ||
					this.extra[3][i] != 0 ||
					this.extra[4][i] != 0;
			}
		}
		else {
			for (i = 0; i < mergeLimit; i++) {
				this.extra[0][i] &= 
					otherInits.extra[0][i];
				this.extra[1][i] |= 
					otherInits.extra[1][i];
				this.extra[4][i] =
					~(~this.extra[2][i] &
							~this.extra[3][i] &
							~this.extra[4][i]) &
					~(this.extra[2][i] & 
							(this.extra[3][i] | 
							this.extra[5][i]));
				this.extra[2][i] = 
				this.extra[3][i] = 0;
				thisHasNulls = thisHasNulls ||
					this.extra[4][i] != 0 ||
					this.extra[5][i] != 0;
			}
		}
		for (; i < copyLimit; i++) {
			this.extra[1][i] = otherInits.extra[1][i];
			this.extra[4][i] =
				~(~otherInits.extra[2][i] &
					~otherInits.extra[3][i] &
					~otherInits.extra[4][i]) &
				~(otherInits.extra[2][i] & 
					(otherInits.extra[3][i] |
					otherInits.extra[5][i]));
			this.extra[5][i] = otherInits.extra[5][i];
			thisHasNulls = thisHasNulls ||
				this.extra[4][i] != 0 ||
				this.extra[5][i] != 0;
		}
		for (; i < resetLimit; i++) {
			this.extra[4][i] =
				~(~this.extra[2][i] &
						~this.extra[3][i] &
						~this.extra[4][i]) &
				~(this.extra[2][i] & 
						(this.extra[3][i] | 
						this.extra[5][i]));
			this.extra[0][i] = 
			this.extra[2][i] = 
			this.extra[3][i] = 0;
			thisHasNulls = thisHasNulls ||
				this.extra[4][i] != 0 ||
				this.extra[5][i] != 0;
		}
	}
	if (thisHasNulls) {
		this.tagBits |= NULL_FLAG_MASK;
	}
	else {
		this.tagBits &= ~NULL_FLAG_MASK;
	}
	return this;
}

/*
 * Answer the total number of fields in enclosing types of a given type
 */
static int numberOfEnclosingFields(ReferenceBinding type){
	int count = 0;
	type = type.enclosingType();
	while(type != null) {
		count += type.fieldCount();
		type = type.enclosingType();
		while(type != null) {
			count += type.fieldCount();
			type = type.enclosingType();
		}
		return count;
	}
	return count;
}

public UnconditionalFlowInfo nullInfoLessUnconditionalCopy() {
	if (this == DEAD_END) {
		return this;
	}
	UnconditionalFlowInfo copy = new UnconditionalFlowInfo();
	copy.definiteInits = this.definiteInits;
	copy.potentialInits = this.potentialInits;
	copy.tagBits = this.tagBits & ~NULL_FLAG_MASK;
	copy.maxFieldCount = this.maxFieldCount;
	if (this.extra != null) {
		int length;
		copy.extra = new long[extraLength][];
		System.arraycopy(this.extra[0], 0, 
			(copy.extra[0] = 
				new long[length = this.extra[0].length]), 0, length);
		System.arraycopy(this.extra[1], 0, 
			(copy.extra[1] = new long[length]), 0, length);
		for (int j = 2; j < extraLength; j++) {
			copy.extra[j] = new long[length];
		}
	}
	return copy;
}

public FlowInfo safeInitsWhenTrue() {
	return copy();
}

public FlowInfo setReachMode(int reachMode) {
	if (reachMode == REACHABLE && this != DEAD_END) { // cannot modify DEAD_END
		this.tagBits &= ~UNREACHABLE;
	}
	else {
		if ((this.tagBits & UNREACHABLE) == 0) {
			// reset optional inits when becoming unreachable
			// see InitializationTest#test090 (and others)
			this.potentialInits = 0;
			if (this.extra != null) {
				for (int i = 0, length = this.extra[0].length; 
						i < length; i++) {
					this.extra[1][i] = 0;
				}
			}
		}				
		this.tagBits |= UNREACHABLE;
	
		return this;
	}
	return this;
}

public String toString(){
	// PREMATURE consider printing bit fields as 0001 0001 1000 0001...
	if (this == DEAD_END){
		return "FlowInfo.DEAD_END"; //$NON-NLS-1$
	}
	if ((this.tagBits & NULL_FLAG_MASK) != 0) {
		if (this.extra == null) {
			return "FlowInfo<def: " + this.definiteInits //$NON-NLS-1$
				+", pot: " + this.potentialInits  //$NON-NLS-1$
				+ ", reachable:" + ((this.tagBits & UNREACHABLE) == 0) //$NON-NLS-1$
				+", nullS1: " + this.nullAssignmentStatusBit1 //$NON-NLS-1$
				+", nullS2: " + this.nullAssignmentStatusBit2 //$NON-NLS-1$
				+", nullV1: " + this.nullAssignmentValueBit1 //$NON-NLS-1$
				+", nullV2: " + this.nullAssignmentValueBit2 //$NON-NLS-1$
				+">"; //$NON-NLS-1$
		}
		else {
			String def = "FlowInfo<def:[" + this.definiteInits, //$NON-NLS-1$
				pot = "], pot:[" + this.potentialInits, //$NON-NLS-1$
				nullS1 = ", nullS1:[" + this.nullAssignmentStatusBit1, //$NON-NLS-1$
				nullS2 = "], nullS2:[" + this.nullAssignmentStatusBit2, //$NON-NLS-1$
				nullV1 = "], nullV1:[" + this.nullAssignmentValueBit1, //$NON-NLS-1$
				nullV2 = "], nullV2:[" + this.nullAssignmentValueBit2; //$NON-NLS-1$
			int i, ceil;
			for (i = 0, ceil = this.extra[0].length > 3 ? 
								3 : 
								this.extra[0].length;
				i < ceil; i++) {
				def += "," + this.extra[0][i]; //$NON-NLS-1$
				pot += "," + this.extra[1][i]; //$NON-NLS-1$
				nullS1 += "," + this.extra[2][i]; //$NON-NLS-1$
				nullS2 += "," + this.extra[3][i]; //$NON-NLS-1$
				nullV1 += "," + this.extra[4][i]; //$NON-NLS-1$
				nullV2 += "," + this.extra[5][i]; //$NON-NLS-1$
			}
			if (ceil < this.extra[0].length) {
				def += ",..."; //$NON-NLS-1$
				pot += ",..."; //$NON-NLS-1$
				nullS1 += ",..."; //$NON-NLS-1$
				nullS2 += ",..."; //$NON-NLS-1$
				nullV1 += ",..."; //$NON-NLS-1$
				nullV2 += ",..."; //$NON-NLS-1$
			}
			return def + pot 
				+ "], reachable:" + ((this.tagBits & UNREACHABLE) == 0) //$NON-NLS-1$
				+ nullS1 + nullS2 + nullV1 + nullV2
				+ "]>"; //$NON-NLS-1$
		}
	}
	else {
		if (this.extra == null) {
			return "FlowInfo<def: " + this.definiteInits //$NON-NLS-1$
				+", pot: " + this.potentialInits  //$NON-NLS-1$
				+ ", reachable:" + ((this.tagBits & UNREACHABLE) == 0) //$NON-NLS-1$
				+", no null info>"; //$NON-NLS-1$
		}
		else {
			String def = "FlowInfo<def:[" + this.definiteInits, //$NON-NLS-1$
				pot = "], pot:[" + this.potentialInits; //$NON-NLS-1$
			int i, ceil;
			for (i = 0, ceil = this.extra[0].length > 3 ? 
								3 : 
								this.extra[0].length;
				i < ceil; i++) {
				def += "," + this.extra[0][i]; //$NON-NLS-1$
				pot += "," + this.extra[1][i]; //$NON-NLS-1$
			}
			if (ceil < this.extra[0].length) {
				def += ",..."; //$NON-NLS-1$
				pot += ",..."; //$NON-NLS-1$
			}
			return def + pot 
				+ "], reachable:" + ((this.tagBits & UNREACHABLE) == 0) //$NON-NLS-1$
				+ ", no null info>"; //$NON-NLS-1$
		}
	}
}

public UnconditionalFlowInfo unconditionalCopy() {
	return (UnconditionalFlowInfo) copy();
}
	
public UnconditionalFlowInfo unconditionalFieldLessCopy() {
	// TODO (maxime) may consider leveraging null contribution verification as it is done in copy
	UnconditionalFlowInfo copy = new UnconditionalFlowInfo();
	copy.tagBits = this.tagBits;
	copy.maxFieldCount = this.maxFieldCount;
	int limit = this.maxFieldCount;
	if (limit < BitCacheSize) {
		long mask;
		copy.definiteInits = this.definiteInits & (mask = ~((1L << limit)-1));
		copy.potentialInits = this.potentialInits & mask;
		copy.nullAssignmentStatusBit1 = this.nullAssignmentStatusBit1 & mask;
		copy.nullAssignmentStatusBit2 = this.nullAssignmentStatusBit2 & mask;
		copy.nullAssignmentValueBit1 = this.nullAssignmentValueBit1 & mask;
		copy.nullAssignmentValueBit2 = this.nullAssignmentValueBit2 & mask;
	} 
	// use extra vector
	if (this.extra == null) {
		return copy; // if vector not yet allocated, then not initialized
	}
	int vectorIndex, length, copyStart;
	if ((vectorIndex = (limit / BitCacheSize) - 1) >= 
			(length = this.extra[0].length)) {
		return copy; // not enough room yet
	}
	long mask;
	copy.extra = new long[extraLength][];
	if ((copyStart = vectorIndex + 1) < length) {
		int copyLength = length - copyStart;
		for (int j = 0; j < extraLength; j++) {
			System.arraycopy(this.extra[j], copyStart, 
				(copy.extra[j] = new long[length]), copyStart, 
				copyLength);
		}
	}
	else if (vectorIndex >= 0) {
		for (int j = 0; j < extraLength; j++) {
			copy.extra[j] = new long[length];
		}
	}
	if (vectorIndex >= 0) {
		mask = ~((1L << (limit % BitCacheSize))-1);
		for (int j = 0; j < extraLength; j++) {
			copy.extra[j][vectorIndex] = 
				this.extra[j][vectorIndex] & mask;
		}
	}
	return copy;
}

public UnconditionalFlowInfo unconditionalInits() {
	// also see conditional inits, where it requests them to merge
	return this;
}

public UnconditionalFlowInfo unconditionalInitsWithoutSideEffect() {
	return this;
}
}

Lines 984-989 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java (+2 lines)
984	case 'n' :	984	case 'n' :
985	if ("nls".equals(warningToken)) //$NON-NLS-1$	985	if ("nls".equals(warningToken)) //$NON-NLS-1$
986	return NonExternalizedString;	986	return NonExternalizedString;
		987	if ("null".equals(warningToken)) //$NON-NLS-1$
		988	return NullReference;
987	break;	989	break;
988	case 's' :	990	case 's' :
989	if ("serial".equals(warningToken)) //$NON-NLS-1$	991	if ("serial".equals(warningToken)) //$NON-NLS-1$

Lines 402-409 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodScope.java (-2 / +3 lines)
402		402
403	if (!flowInfo.isReachable()) return -1;	403	if (!flowInfo.isReachable()) return -1;
404		404
405	UnconditionalFlowInfo unconditionalFlowInfo = flowInfo.unconditionalInits();	405	UnconditionalFlowInfo unconditionalFlowInfo = flowInfo.unconditionalInitsWithoutSideEffect();
406	long[] extraInits = unconditionalFlowInfo.extraDefiniteInits;	406	long[] extraInits = unconditionalFlowInfo.extra == null ?
		407	null : unconditionalFlowInfo.extra[0];
407	long inits = unconditionalFlowInfo.definiteInits;	408	long inits = unconditionalFlowInfo.definiteInits;
408	checkNextEntry : for (int i = lastIndex; --i >= 0;) {	409	checkNextEntry : for (int i = lastIndex; --i >= 0;) {
409	if (definiteInits[i] == inits) {	410	if (definiteInits[i] == inits) {





		case IProblem.LocalVariableCannotBeNull :
		case IProblem.LocalVariableCanOnlyBeNull :
		case IProblem.LocalVariableMayBeNull :
			return CompilerOptions.NullReference;
			
		case IProblem.BoxingConversion :

			local.sourceEnd);
	}
}
public void localVariableMayBeNull(LocalVariableBinding local, ASTNode location) {
	String[] arguments = new String[] {new String(local.name)};
	this.handle(
		IProblem.LocalVariableMayBeNull,
		arguments,
		arguments,
		location.sourceStart,
		location.sourceEnd);
}
public void methodMustOverride(AbstractMethodDeclaration method) {
	MethodBinding binding = method.binding;
	this.handle(

Lines 324-329 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+1 lines)
324	396 = Illegal modifier for the variable {0}; only final is permitted	324	396 = Illegal modifier for the variable {0}; only final is permitted
325	397 = The variable {0} cannot be null; it was either set to a non-null value or assumed to be non-null when last used	325	397 = The variable {0} cannot be null; it was either set to a non-null value or assumed to be non-null when last used
326	398 = The variable {0} can only be null; it was either set to null or checked for null when last used	326	398 = The variable {0} can only be null; it was either set to null or checked for null when last used
		327	399 = The variable {0} may be null
327		328
328	400 = The type {3} must implement the inherited abstract method {2}.{0}({1})	329	400 = The type {3} must implement the inherited abstract method {2}.{0}({1})
329	401 = Cannot override the final method from {0}	330	401 = Cannot override the final method from {0}

Return to bug 110030

Lines 1374-1379 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (+10 lines)
1374		1374
1375	case IProblem.LocalVariableCannotBeNull :	1375	case IProblem.LocalVariableCannotBeNull :
1376	case IProblem.LocalVariableCanOnlyBeNull :	1376	case IProblem.LocalVariableCanOnlyBeNull :
		1377	case IProblem.LocalVariableMayBeNull :
1377	return CompilerOptions.NullReference;	1378	return CompilerOptions.NullReference;
1378		1379
1379	case IProblem.BoxingConversion :	1380	case IProblem.BoxingConversion :
Lines 3980-3985 Link Here
3980	local.sourceEnd);	3981	local.sourceEnd);
3981	}	3982	}
3982	}	3983	}
		3984	public void localVariableMayBeNull(LocalVariableBinding local, ASTNode location) {
		3985	String[] arguments = new String[] {new String(local.name)};
		3986	this.handle(
		3987	IProblem.LocalVariableMayBeNull,
		3988	arguments,
		3989	arguments,
		3990	location.sourceStart,
		3991	location.sourceEnd);
		3992	}
3983	public void methodMustOverride(AbstractMethodDeclaration method) {	3993	public void methodMustOverride(AbstractMethodDeclaration method) {
3984	MethodBinding binding = method.binding;	3994	MethodBinding binding = method.binding;
3985	this.handle(	3995	this.handle(

Lines 49-55 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AND_AND_Expression.java (-6 / +5 lines)
49	// need to be careful of scenario:	49	// need to be careful of scenario:
50	// (x && y) && !z, if passing the left info to the right, it would be	50	// (x && y) && !z, if passing the left info to the right, it would be
51	// swapped by the !	51	// swapped by the !
52	FlowInfo rightInfo = leftInfo.initsWhenTrue().unconditionalInits().copy();	52	FlowInfo rightInfo = leftInfo.initsWhenTrue().unconditionalCopy();
53	rightInitStateIndex = currentScope.methodScope().recordInitializationStates(rightInfo);	53	rightInitStateIndex = currentScope.methodScope().recordInitializationStates(rightInfo);
54		54
55	int previousMode = rightInfo.reachMode();	55	int previousMode = rightInfo.reachMode();
Lines 57-68 Link Here
57	rightInfo.setReachMode(FlowInfo.UNREACHABLE);	57	rightInfo.setReachMode(FlowInfo.UNREACHABLE);
58	}	58	}
59	rightInfo = right.analyseCode(currentScope, flowContext, rightInfo);	59	rightInfo = right.analyseCode(currentScope, flowContext, rightInfo);
60	FlowInfo trueMergedInfo = rightInfo.initsWhenTrue().copy();
61	rightInfo.setReachMode(previousMode); // reset after trueMergedInfo got extracted
62	FlowInfo mergedInfo = FlowInfo.conditional(	60	FlowInfo mergedInfo = FlowInfo.conditional(
63	trueMergedInfo,	61	rightInfo.safeInitsWhenTrue(),
64	leftInfo.initsWhenFalse().copy().unconditionalInits().mergedWith(	62	leftInfo.initsWhenFalse().unconditionalInits().mergedWith(
65	rightInfo.initsWhenFalse().copy().unconditionalInits()));	63	rightInfo.initsWhenFalse().setReachMode(previousMode).unconditionalInits()));
		64	// reset after trueMergedInfo got extracted
66	mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);	65	mergedInitStateIndex = currentScope.methodScope().recordInitializationStates(mergedInfo);
67	return mergedInfo;	66	return mergedInfo;
68	}	67	}

Lines 27-60 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayReference.java (-19 / +21 lines)
27	sourceStart = rec.sourceStart;	27	sourceStart = rec.sourceStart;
28	}	28	}
29		29
30	public FlowInfo analyseAssignment(	30	public FlowInfo analyseAssignment(
31	BlockScope currentScope,	31	BlockScope currentScope,
32	FlowContext flowContext,	32	FlowContext flowContext,
33	FlowInfo flowInfo,	33	FlowInfo flowInfo,
34	Assignment assignment,	34	Assignment assignment,
35	boolean compoundAssignment) {	35	boolean compoundAssignment) {
		36	// unconditionalInits is applied to all existing calls -> we remove extraneous ones here
		37	if (assignment.expression == null) {
		38	return analyseCode(currentScope, flowContext, flowInfo);
		39	}
		40	return assignment
		41	.expression
		42	.analyseCode(
		43	currentScope,
		44	flowContext,
		45	analyseCode(currentScope, flowContext, flowInfo).unconditionalInits());
		46	}
36		47
37	if (assignment.expression == null) {	48	public FlowInfo analyseCode(
38	return analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
39	}
40	return assignment
41	.expression
42	.analyseCode(
43	currentScope,
44	flowContext,
45	analyseCode(currentScope, flowContext, flowInfo).unconditionalInits())
46	.unconditionalInits();
47	}
48
49	public FlowInfo analyseCode(
50	BlockScope currentScope,	49	BlockScope currentScope,
51	FlowContext flowContext,	50	FlowContext flowContext,
52	FlowInfo flowInfo) {	51	FlowInfo flowInfo) {
53		52	receiver.checkNPE(currentScope, flowContext, flowInfo, true);
54	flowInfo = receiver.analyseCode(currentScope, flowContext, flowInfo);	53	flowInfo = receiver.analyseCode(currentScope, flowContext, flowInfo);
55	receiver.checkNullStatus(currentScope, flowContext, flowInfo, FlowInfo.NON_NULL);	54	return position.analyseCode(currentScope, flowContext, flowInfo);
56	return position.analyseCode(currentScope, flowContext, flowInfo);	55	}
57	}
58		56
59	public void generateAssignment(	57	public void generateAssignment(
60	BlockScope currentScope,	58	BlockScope currentScope,
Lines 179-184 Link Here
179	codeStream.arrayAtPut(this.resolvedType.id, false);	177	codeStream.arrayAtPut(this.resolvedType.id, false);
180	}	178	}
181		179
		180	public int nullStatus(FlowInfo flowInfo) {
		181	return FlowInfo.UNKNOWN;
		182	}
		183
182	public StringBuffer printExpression(int indent, StringBuffer output) {	184	public StringBuffer printExpression(int indent, StringBuffer output) {
183		185
184	receiver.printExpression(0, output).append('[');	186	receiver.printExpression(0, output).append('[');

Lines 36-69 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java (-28 / +36 lines)
36	this.sourceEnd = sourceEnd;	36	this.sourceEnd = sourceEnd;
37	}	37	}
38		38
39	public FlowInfo analyseCode(	39	public FlowInfo analyseCode(
40	BlockScope currentScope,	40	BlockScope currentScope,
41	FlowContext flowContext,	41	FlowContext flowContext,
42	FlowInfo flowInfo) {	42	FlowInfo flowInfo) {
43	// record setting a variable: various scenarii are possible, setting an array reference,	43	// record setting a variable: various scenarii are possible, setting an array reference,
44	// a field reference, a blank final field reference, a field of an enclosing instance or	44	// a field reference, a blank final field reference, a field of an enclosing instance or
45	// just a local variable.	45	// just a local variable.
46		46	LocalVariableBinding local = this.lhs.localVariableBinding();
47	LocalVariableBinding local = this.lhs.localVariableBinding();	47	int nullStatus = this.expression.nullStatus(flowInfo);
48	int nullStatus = this.expression.nullStatus(flowInfo);	48	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
49	if (local != null && nullStatus == FlowInfo.NULL) {	49	if (nullStatus == FlowInfo.NULL) {
50	flowContext.recordUsingNullReference(currentScope, local, this.lhs, FlowInfo.NON_NULL, flowInfo);	50	flowContext.recordUsingNullReference(currentScope, local, this.lhs,
51	}	51	FlowContext.CAN_ONLY_NULL, flowInfo);
52	flowInfo = ((Reference) lhs)	52	}
53	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)	53	}
54	.unconditionalInits();	54	flowInfo = ((Reference) lhs)
55	if (local != null) {	55	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
56	switch(nullStatus) {	56	.unconditionalInits();
57	case FlowInfo.NULL :	57	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
58	flowInfo.markAsDefinitelyNull(local);	58	switch(nullStatus) {
59	break;	59	case FlowInfo.NULL :
60	case FlowInfo.NON_NULL :	60	flowInfo.markAsDefinitelyNull(local);
61	flowInfo.markAsDefinitelyNonNull(local);	61	break;
62	break;	62	case FlowInfo.NON_NULL :
63	}	63	flowInfo.markAsDefinitelyNonNull(local);
64	}	64	break;
65	return flowInfo;	65	default:
66	}	66	flowInfo.markAsDefinitelyUnknown(local);
		67	}
		68	}
		69	return flowInfo;
		70	}
67		71
68	void checkAssignmentEffect(BlockScope scope) {	72	void checkAssignmentEffect(BlockScope scope) {
69		73
Lines 250-253 Link Here
250	}	254	}
251	visitor.endVisit(this, scope);	255	visitor.endVisit(this, scope);
252	}	256	}
		257
		258	public LocalVariableBinding localVariableBinding() {
		259	return lhs.localVariableBinding();
		260	}
253	}	261	}

Lines 31-48 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/BinaryExpression.java (-9 / +8 lines)
31	this.sourceEnd = right.sourceEnd;	31	this.sourceEnd = right.sourceEnd;
32	}	32	}
33		33
34	public FlowInfo analyseCode(	34	public FlowInfo analyseCode(
35	BlockScope currentScope,	35	BlockScope currentScope,
36	FlowContext flowContext,	36	FlowContext flowContext,
37	FlowInfo flowInfo) {	37	FlowInfo flowInfo) {
38		38	left.checkNPE(currentScope, flowContext, flowInfo, false /* skip String */);
39	return right	39	flowInfo = left.analyseCode(currentScope, flowContext, flowInfo).
40	.analyseCode(	40	unconditionalInits();
41	currentScope,	41	right.checkNPE(currentScope, flowContext, flowInfo, false /* skip String */);
42	flowContext,	42	return right.analyseCode(currentScope, flowContext, flowInfo).
43	left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits())	43	unconditionalInits();
44	.unconditionalInits();	44	}
45	}
46		45
47	public void computeConstant(BlockScope scope, int leftId, int rightId) {	46	public void computeConstant(BlockScope scope, int leftId, int rightId) {
48		47

Lines 34-46 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/CompoundAssignment.java (-10 / +12 lines)
34	this.operator = operator ;	34	this.operator = operator ;
35	}	35	}
36		36
37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
38	// record setting a variable: various scenarii are possible, setting an array reference,	38	FlowInfo flowInfo) {
39	// a field reference, a blank final field reference, a field of an enclosing instance or	39	// record setting a variable: various scenarii are possible, setting an array reference,
40	// just a local variable.	40	// a field reference, a blank final field reference, a field of an enclosing instance or
41		41	// just a local variable.
42	return ((Reference) lhs).analyseAssignment(currentScope, flowContext, flowInfo, this, true).unconditionalInits();	42	lhs.checkNPE(currentScope, flowContext, flowInfo, false /* skip String */);
43	}	43	return ((Reference) lhs).analyseAssignment(currentScope, flowContext, flowInfo, this, true).unconditionalInits();
		44	}
44		45
45	public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {	46	public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
46		47
Lines 56-64 Link Here
56	codeStream.recordPositionsFrom(pc, this.sourceStart);	57	codeStream.recordPositionsFrom(pc, this.sourceStart);
57	}	58	}
58		59
59	public int nullStatus(FlowInfo flowInfo) {	60	public int nullStatus(FlowInfo flowInfo) {
60	return FlowInfo.NON_NULL;	61	return FlowInfo.NON_NULL;
61	}	62	// we may have complained on checkNPE, but we avoid duplicate error
		63	}
62		64
63	public String operatorToString() {	65	public String operatorToString() {
64	switch (operator) {	66	switch (operator) {

Lines 40-50 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java (-11 / +22 lines)
40	sourceEnd = valueIfFalse.sourceEnd;	40	sourceEnd = valueIfFalse.sourceEnd;
41	}	41	}
42		42
43	public FlowInfo analyseCode(	43	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
44	BlockScope currentScope,
45	FlowContext flowContext,
46	FlowInfo flowInfo) {	44	FlowInfo flowInfo) {
47
48	Constant cst = this.condition.optimizedBooleanConstant();	45	Constant cst = this.condition.optimizedBooleanConstant();
49	boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;	46	boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;
50	boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;	47	boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;
Lines 84-99 Link Here
84	boolean isValueIfFalseOptimizedTrue = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == true;	81	boolean isValueIfFalseOptimizedTrue = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == true;
85	boolean isValueIfFalseOptimizedFalse = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == false;	82	boolean isValueIfFalseOptimizedFalse = cst != null && cst != Constant.NotAConstant && cst.booleanValue() == false;
86		83
87	UnconditionalFlowInfo trueInfoWhenTrue = trueFlowInfo.initsWhenTrue().copy().unconditionalInits();	84	UnconditionalFlowInfo trueInfoWhenTrue = trueFlowInfo.initsWhenTrue().unconditionalCopy();
		85	UnconditionalFlowInfo falseInfoWhenTrue = falseFlowInfo.initsWhenTrue().unconditionalCopy();
		86	UnconditionalFlowInfo trueInfoWhenFalse = trueFlowInfo.initsWhenFalse().unconditionalInits();
		87	UnconditionalFlowInfo falseInfoWhenFalse = falseFlowInfo.initsWhenFalse().unconditionalInits();
88	if (isValueIfTrueOptimizedFalse) trueInfoWhenTrue.setReachMode(FlowInfo.UNREACHABLE);	88	if (isValueIfTrueOptimizedFalse) trueInfoWhenTrue.setReachMode(FlowInfo.UNREACHABLE);
89
90	UnconditionalFlowInfo falseInfoWhenTrue = falseFlowInfo.initsWhenTrue().copy().unconditionalInits();
91	if (isValueIfFalseOptimizedFalse) falseInfoWhenTrue.setReachMode(FlowInfo.UNREACHABLE);	89	if (isValueIfFalseOptimizedFalse) falseInfoWhenTrue.setReachMode(FlowInfo.UNREACHABLE);
92
93	UnconditionalFlowInfo trueInfoWhenFalse = trueFlowInfo.initsWhenFalse().copy().unconditionalInits();
94	if (isValueIfTrueOptimizedTrue) trueInfoWhenFalse.setReachMode(FlowInfo.UNREACHABLE);	90	if (isValueIfTrueOptimizedTrue) trueInfoWhenFalse.setReachMode(FlowInfo.UNREACHABLE);
95
96	UnconditionalFlowInfo falseInfoWhenFalse = falseFlowInfo.initsWhenFalse().copy().unconditionalInits();
97	if (isValueIfFalseOptimizedTrue) falseInfoWhenFalse.setReachMode(FlowInfo.UNREACHABLE);	91	if (isValueIfFalseOptimizedTrue) falseInfoWhenFalse.setReachMode(FlowInfo.UNREACHABLE);
98		92
99	mergedInfo =	93	mergedInfo =
Lines 262-267 Link Here
262	// no implicit conversion for boolean values	256	// no implicit conversion for boolean values
263	codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);	257	codeStream.updateLastRecordedEndPC(currentScope, codeStream.position);
264	}	258	}
		259
		260	public int nullStatus(FlowInfo flowInfo) {
		261	Constant cst = this.condition.optimizedBooleanConstant();
		262	if (cst != Constant.NotAConstant) {
		263	if (cst.booleanValue()) {
		264	return valueIfTrue.nullStatus(flowInfo);
		265	}
		266	return valueIfFalse.nullStatus(flowInfo);
		267	}
		268	int ifTrueNullStatus = valueIfTrue.nullStatus(flowInfo),
		269	ifFalseNullStatus = valueIfFalse.nullStatus(flowInfo);
		270	if (ifTrueNullStatus == ifFalseNullStatus) {
		271	return ifTrueNullStatus;
		272	}
		273	return FlowInfo.UNKNOWN;
		274	// cannot decide which branch to take, and they disagree
		275	}
265		276
266	public Constant optimizedBooleanConstant() {	277	public Constant optimizedBooleanConstant() {
267		278

Lines 22-105 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java (-28 / +42 lines)
22	public EqualExpression(Expression left, Expression right,int operator) {	22	public EqualExpression(Expression left, Expression right,int operator) {
23	super(left,right,operator);	23	super(left,right,operator);
24	}	24	}
25	public void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {	25	private void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {
26		26
27	LocalVariableBinding local = this.left.localVariableBinding();	27	LocalVariableBinding local = this.left.localVariableBinding();
28	if (local != null) {	28	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
29	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, right.nullStatus(flowInfo), this.left);	29	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, right.nullStatus(flowInfo), this.left);
30	}	30	}
31	local = this.right.localVariableBinding();	31	local = this.right.localVariableBinding();
32	if (local != null) {	32	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
33	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, left.nullStatus(flowInfo), this.right);	33	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, left.nullStatus(flowInfo), this.right);
34	}	34	}
35	}	35	}
36	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, LocalVariableBinding local, int nullStatus, Expression reference) {	36	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, LocalVariableBinding local, int nullStatus, Expression reference) {
37	switch (nullStatus) {	37	switch (nullStatus) {
38	case FlowInfo.NULL :	38	case FlowInfo.NULL :
39	flowContext.recordUsingNullReference(scope, local, reference, FlowInfo.NULL, flowInfo);	39	flowContext.recordUsingNullReference(scope, local, reference,
		40	FlowContext.CAN_ONLY_NULL_NON_NULL, flowInfo);
40	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	41	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
41	initsWhenTrue.markAsDefinitelyNull(local); // from thereon it is set	42	initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set
42	initsWhenFalse.markAsDefinitelyNonNull(local); // from thereon it is set	43	initsWhenFalse.markAsComparedEqualToNonNull(local); // from thereon it is set
43	} else {	44	} else {
44	initsWhenTrue.markAsDefinitelyNonNull(local); // from thereon it is set	45	initsWhenTrue.markAsComparedEqualToNonNull(local); // from thereon it is set
45	initsWhenFalse.markAsDefinitelyNull(local); // from thereon it is set	46	initsWhenFalse.markAsComparedEqualToNull(local); // from thereon it is set
46	}	47	}
47	break;	48	break;
48	case FlowInfo.NON_NULL :	49	case FlowInfo.NON_NULL :
49	flowContext.recordUsingNullReference(scope, local, reference, FlowInfo.NON_NULL, flowInfo);	50	flowContext.recordUsingNullReference(scope, local, reference,
		51	FlowContext.CAN_ONLY_NULL, flowInfo);
50	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	52	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
51	initsWhenTrue.markAsDefinitelyNonNull(local); // from thereon it is set	53	initsWhenTrue.markAsComparedEqualToNonNull(local); // from thereon it is set
52	}	54	}
53	break;	55	break;
54	}	56	}
55	}	57	}
56		58
57	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	59	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
		60	FlowInfo result;
58	if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	61	if (((bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
59	if ((left.constant != Constant.NotAConstant) && (left.constant.typeID() == T_boolean)) {	62	if ((left.constant != Constant.NotAConstant) && (left.constant.typeID() == T_boolean)) {
60	if (left.constant.booleanValue()) { // true == anything	63	if (left.constant.booleanValue()) { // true == anything
61	// this is equivalent to the right argument inits	64	// this is equivalent to the right argument inits
62	return right.analyseCode(currentScope, flowContext, flowInfo);	65	result = right.analyseCode(currentScope, flowContext, flowInfo);
63	} else { // false == anything	66	} else { // false == anything
64	// this is equivalent to the right argument inits negated	67	// this is equivalent to the right argument inits negated
65	return right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();	68	result = right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
66	}	69	}
67	}	70	}
68	if ((right.constant != Constant.NotAConstant) && (right.constant.typeID() == T_boolean)) {	71	else if ((right.constant != Constant.NotAConstant) && (right.constant.typeID() == T_boolean)) {
69	if (right.constant.booleanValue()) { // anything == true	72	if (right.constant.booleanValue()) { // anything == true
70	// this is equivalent to the right argument inits	73	// this is equivalent to the left argument inits
71	return left.analyseCode(currentScope, flowContext, flowInfo);	74	result = left.analyseCode(currentScope, flowContext, flowInfo);
72	} else { // anything == false	75	} else { // anything == false
73	// this is equivalent to the right argument inits negated	76	// this is equivalent to the right argument inits negated
74	return left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();	77	result = left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
75	}	78	}
		79	}
		80	else {
		81	result = right.analyseCode(
		82	currentScope, flowContext,
		83	left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).unconditionalInits();
76	}	84	}
77	return right.analyseCode(
78	currentScope, flowContext,
79	left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).unconditionalInits();
80	} else { //NOT_EQUAL :	85	} else { //NOT_EQUAL :
81	if ((left.constant != Constant.NotAConstant) && (left.constant.typeID() == T_boolean)) {	86	if ((left.constant != Constant.NotAConstant) && (left.constant.typeID() == T_boolean)) {
82	if (!left.constant.booleanValue()) { // false != anything	87	if (!left.constant.booleanValue()) { // false != anything
83	// this is equivalent to the right argument inits	88	// this is equivalent to the right argument inits
84	return right.analyseCode(currentScope, flowContext, flowInfo);	89	result = right.analyseCode(currentScope, flowContext, flowInfo);
85	} else { // true != anything	90	} else { // true != anything
86	// this is equivalent to the right argument inits negated	91	// this is equivalent to the right argument inits negated
87	return right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();	92	result = right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
88	}	93	}
89	}	94	}
90	if ((right.constant != Constant.NotAConstant) && (right.constant.typeID() == T_boolean)) {	95	else if ((right.constant != Constant.NotAConstant) && (right.constant.typeID() == T_boolean)) {
91	if (!right.constant.booleanValue()) { // anything != false	96	if (!right.constant.booleanValue()) { // anything != false
92	// this is equivalent to the right argument inits	97	// this is equivalent to the right argument inits
93	return left.analyseCode(currentScope, flowContext, flowInfo);	98	result = left.analyseCode(currentScope, flowContext, flowInfo);
94	} else { // anything != true	99	} else { // anything != true
95	// this is equivalent to the right argument inits negated	100	// this is equivalent to the right argument inits negated
96	return left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();	101	result = left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();
97	}	102	}
		103	}
		104	else {
		105	result = right.analyseCode(
		106	currentScope, flowContext,
		107	left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).
		108	/* unneeded since we flatten it: asNegatedCondition(). */
		109	unconditionalInits();
98	}	110	}
99	return right.analyseCode(
100	currentScope, flowContext,
101	left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).asNegatedCondition().unconditionalInits();
102	}	111	}
		112	if (result instanceof UnconditionalFlowInfo && result.isReachable()) { // the flow info is flat
		113	result = FlowInfo.conditional(result, result.copy());
		114	}
		115	checkNullComparison(currentScope, flowContext, result, result.initsWhenTrue(), result.initsWhenFalse());
		116	return result;
103	}	117	}
104		118
105	public final void computeConstant(TypeBinding leftType, TypeBinding rightType) {	119	public final void computeConstant(TypeBinding leftType, TypeBinding rightType) {

Lines 479-503 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Expression.java (-21 / +21 lines)
479	}	479	}
480	}	480	}
481		481
482	public FlowInfo checkNullStatus(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, int nullStatus) {	482	/**
483		483	* Check the local variable of this expression, if any, against potential NPEs
484	LocalVariableBinding local = this.localVariableBinding();	484	* given a flow context and an upstream flow info. If so, report the risk to
485	if (local != null) {	485	* the context. Marks the local as checked, which affects the flow info.
486	switch(nullStatus) {	486	* @param scope the scope of the analysis
487	case FlowInfo.NULL :	487	* @param flowContext the current flow context
488	flowContext.recordUsingNullReference(scope, local, this, FlowInfo.NULL, flowInfo);	488	* @param flowInfo the upstream flow info; caveat: may get modified
489	flowInfo.markAsDefinitelyNull(local); // from thereon it is set	489	* @param checkString if true, a local variable of type String is checked; else
490	break;	490	* it is skipped
491	case FlowInfo.NON_NULL :	491	*/
492	flowContext.recordUsingNullReference(scope, local, this, FlowInfo.NON_NULL, flowInfo);	492	public void checkNPE(BlockScope scope, FlowContext flowContext,
493	flowInfo.markAsDefinitelyNonNull(local); // from thereon it is set	493	FlowInfo flowInfo, boolean checkString) {
494	break;	494	LocalVariableBinding local = this.localVariableBinding();
495	case FlowInfo.UNKNOWN :	495	if (local != null &&
496	break;	496	(local.type.tagBits & TagBits.IsBaseType) == 0 &&
497	}	497	(checkString \|\| local.type.id != T_JavaLangString)) {
498	}	498	flowContext.recordUsingNullReference(scope, local, this,
499	return flowInfo;	499	FlowContext.MAY_NULL, flowInfo);
		500	flowInfo.markAsComparedEqualToNonNull(local);
		501	// from thereon it is set
500	}	502	}
		503	}
501		504
502	private MethodBinding[] getAllInheritedMethods(ReferenceBinding binding) {	505	private MethodBinding[] getAllInheritedMethods(ReferenceBinding binding) {
503	ArrayList collector = new ArrayList();	506	ArrayList collector = new ArrayList();
Lines 516-524 Link Here
516	getAllInheritedMethods0(superInterfaces[i], collector);	519	getAllInheritedMethods0(superInterfaces[i], collector);
517	}	520	}
518	}	521	}
519	public void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {
520	// do nothing by default - see EqualExpression
521	}
522		522
523	public boolean checkUnsafeCast(Scope scope, TypeBinding castType, TypeBinding expressionType, TypeBinding match, boolean isNarrowing) {	523	public boolean checkUnsafeCast(Scope scope, TypeBinding castType, TypeBinding expressionType, TypeBinding match, boolean isNarrowing) {
524	if (match == castType) {	524	if (match == castType) {

Lines 83-120 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ForStatement.java (-22 / +55 lines)
83		83
84	// process the condition	84	// process the condition
85	LoopingFlowContext condLoopContext = null;	85	LoopingFlowContext condLoopContext = null;
86	FlowInfo condInfo = flowInfo.copy().unconditionalInits().discardNullRelatedInitializations();	86	FlowInfo condInfo = flowInfo.nullInfoLessUnconditionalCopy();
87	if (condition != null) {	87	if (condition != null) {
88	if (!isConditionTrue) {	88	if (!isConditionTrue) {
89	condInfo =	89	condInfo =
90	condition.analyseCode(	90	condition.analyseCode(
91	scope,	91	scope,
92	(condLoopContext =	92	(condLoopContext =
93	new LoopingFlowContext(flowContext, this, null, null, scope)),	93	new LoopingFlowContext(flowContext, flowInfo, this, null,
		94	null, scope)),
94	condInfo);	95	condInfo);
95	}	96	}
96	}	97	}
97		98
98	// process the action	99	// process the action
99	LoopingFlowContext loopingContext;	100	LoopingFlowContext loopingContext;
100	FlowInfo actionInfo;	101	UnconditionalFlowInfo actionInfo;
101	if (action == null	102	if (action == null
102	\|\| (action.isEmptyBlock() && currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3)) {	103	\|\| (action.isEmptyBlock() && currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3)) {
103	if (condLoopContext != null)	104	if (condLoopContext != null)
104	condLoopContext.complainOnDeferredChecks(scope, condInfo);	105	condLoopContext.complainOnDeferredFinalChecks(scope, condInfo);
105	if (isConditionTrue) {	106	if (isConditionTrue) {
		107	if (condLoopContext != null) {
		108	condLoopContext.complainOnDeferredNullChecks(currentScope,
		109	condInfo);
		110	}
106	return FlowInfo.DEAD_END;	111	return FlowInfo.DEAD_END;
107	} else {	112	} else {
108	if (isConditionFalse){	113	if (isConditionFalse){
109	continueLabel = null; // for(;false;p());	114	continueLabel = null; // for(;false;p());
110	}	115	}
111	actionInfo = condInfo.initsWhenTrue().copy().unconditionalInits().discardNullRelatedInitializations();	116	actionInfo = condInfo.initsWhenTrue().unconditionalCopy();
112	loopingContext =	117	loopingContext =
113	new LoopingFlowContext(flowContext, this, breakLabel, continueLabel, scope);	118	new LoopingFlowContext(flowContext, flowInfo, this,
		119	breakLabel, continueLabel, scope);
114	}	120	}
115	} else {	121	}
		122	else {
116	loopingContext =	123	loopingContext =
117	new LoopingFlowContext(flowContext, this, breakLabel, continueLabel, scope);	124	new LoopingFlowContext(flowContext, flowInfo, this, breakLabel,
		125	continueLabel, scope);
118	FlowInfo initsWhenTrue = condInfo.initsWhenTrue();	126	FlowInfo initsWhenTrue = condInfo.initsWhenTrue();
119	condIfTrueInitStateIndex =	127	condIfTrueInitStateIndex =
120	currentScope.methodScope().recordInitializationStates(initsWhenTrue);	128	currentScope.methodScope().recordInitializationStates(initsWhenTrue);
Lines 122-159 Link Here
122	if (isConditionFalse) {	130	if (isConditionFalse) {
123	actionInfo = FlowInfo.DEAD_END;	131	actionInfo = FlowInfo.DEAD_END;
124	} else {	132	} else {
125	actionInfo = initsWhenTrue.copy().unconditionalInits().discardNullRelatedInitializations();	133	actionInfo = initsWhenTrue.unconditionalCopy();
126	if (isConditionOptimizedFalse){	134	if (isConditionOptimizedFalse){
127	actionInfo.setReachMode(FlowInfo.UNREACHABLE);	135	actionInfo.setReachMode(FlowInfo.UNREACHABLE);
128	}	136	}
129	}	137	}
130	if (!this.action.complainIfUnreachable(actionInfo, scope, false)) {	138	if (!this.action.complainIfUnreachable(actionInfo, scope, false)) {
131	actionInfo = action.analyseCode(scope, loopingContext, actionInfo);	139	actionInfo = action.analyseCode(scope, loopingContext, actionInfo).
		140	unconditionalInits();
132	}	141	}
133		142
134	// code generation can be optimized when no need to continue in the loop	143	// code generation can be optimized when no need to continue in the loop
135	if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {	144	if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {
136	continueLabel = null;	145	continueLabel = null;
137	} else {	146	}
138	if (condLoopContext != null)	147	else {
139	condLoopContext.complainOnDeferredChecks(scope, condInfo);	148	if (condLoopContext != null) {
140	actionInfo = actionInfo.mergedWith(loopingContext.initsOnContinue.unconditionalInits());	149	condLoopContext.complainOnDeferredFinalChecks(scope,
141	loopingContext.complainOnDeferredChecks(scope, actionInfo);	150	condInfo);
		151	}
		152	actionInfo = actionInfo.mergedWith(loopingContext.initsOnContinue);
		153	loopingContext.complainOnDeferredFinalChecks(scope,
		154	actionInfo);
142	}	155	}
143	}	156	}
144	// for increments	157	// for increments
145	FlowInfo exitBranch = condInfo.initsWhenFalse();	158	FlowInfo exitBranch = flowInfo.copy();
146	exitBranch.addInitializationsFrom(flowInfo); // recover null inits from before condition analysis	159	// recover null inits from before condition analysis
		160	LoopingFlowContext incrementContext = null;
147	if (continueLabel != null) {	161	if (continueLabel != null) {
148	if (increments != null) {	162	if (increments != null) {
149	LoopingFlowContext loopContext =	163	incrementContext =
150	new LoopingFlowContext(flowContext, this, null, null, scope);	164	new LoopingFlowContext(flowContext, flowInfo, this, null,
		165	null, scope);
		166	FlowInfo incrementInfo = actionInfo;
151	for (int i = 0, count = increments.length; i < count; i++) {	167	for (int i = 0, count = increments.length; i < count; i++) {
152	actionInfo = increments[i].analyseCode(scope, loopContext, actionInfo);	168	incrementInfo = increments[i].
		169	analyseCode(scope, incrementContext, incrementInfo);
153	}	170	}
154	loopContext.complainOnDeferredChecks(scope, actionInfo);	171	incrementContext.complainOnDeferredFinalChecks(scope,
		172	actionInfo = incrementInfo.unconditionalInits());
155	}	173	}
156	exitBranch.addPotentialInitializationsFrom(actionInfo.unconditionalInits());	174	exitBranch.addPotentialInitializationsFrom(actionInfo).
		175	addInitializationsFrom(condInfo.initsWhenFalse());
		176	}
		177	else {
		178	exitBranch.addInitializationsFrom(condInfo.initsWhenFalse());
		179	}
		180	// nulls checks
		181	if (condLoopContext != null) {
		182	condLoopContext.complainOnDeferredNullChecks(currentScope,
		183	actionInfo);
		184	}
		185	loopingContext.complainOnDeferredNullChecks(currentScope,
		186	actionInfo);
		187	if (incrementContext != null) {
		188	incrementContext.complainOnDeferredNullChecks(currentScope,
		189	actionInfo);
157	}	190	}
158		191
159	//end of loop	192	//end of loop

Lines 17-22 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java (-10 / +18 lines)
17	import org.eclipse.jdt.internal.compiler.flow.FlowContext;	17	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
18	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;	18	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
19	import org.eclipse.jdt.internal.compiler.flow.LoopingFlowContext;	19	import org.eclipse.jdt.internal.compiler.flow.LoopingFlowContext;
		20	import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo;
20	import org.eclipse.jdt.internal.compiler.impl.Constant;	21	import org.eclipse.jdt.internal.compiler.impl.Constant;
21	import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;	22	import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
22	import org.eclipse.jdt.internal.compiler.lookup.Binding;	23	import org.eclipse.jdt.internal.compiler.lookup.Binding;
Lines 81-89 Link Here
81	continueLabel = new Label();	82	continueLabel = new Label();
82		83
83	// process the element variable and collection	84	// process the element variable and collection
		85	this.collection.checkNPE(currentScope, flowContext, flowInfo, true);
84	flowInfo = this.elementVariable.analyseCode(scope, flowContext, flowInfo);	86	flowInfo = this.elementVariable.analyseCode(scope, flowContext, flowInfo);
85	FlowInfo condInfo = flowInfo.copy().unconditionalInits().discardNullRelatedInitializations();	87	FlowInfo condInfo = this.collection.analyseCode(scope, flowContext, flowInfo.copy());
86	condInfo = this.collection.analyseCode(scope, flowContext, condInfo);
87		88
88	// element variable will be assigned when iterating	89	// element variable will be assigned when iterating
89	condInfo.markAsDefinitelyAssigned(this.elementVariable.binding);	90	condInfo.markAsDefinitelyAssigned(this.elementVariable.binding);
Lines 91-115 Link Here
91	this.postCollectionInitStateIndex = currentScope.methodScope().recordInitializationStates(condInfo);	92	this.postCollectionInitStateIndex = currentScope.methodScope().recordInitializationStates(condInfo);
92		93
93	// process the action	94	// process the action
94	LoopingFlowContext loopingContext = new LoopingFlowContext(flowContext, this, breakLabel, continueLabel, scope);	95	LoopingFlowContext loopingContext =
95	FlowInfo actionInfo = condInfo.initsWhenTrue().copy();	96	new LoopingFlowContext(flowContext, flowInfo, this, breakLabel,
		97	continueLabel, scope);
		98	UnconditionalFlowInfo actionInfo =
		99	condInfo.nullInfoLessUnconditionalCopy();
96	FlowInfo exitBranch;	100	FlowInfo exitBranch;
97	if (!(action == null \|\| (action.isEmptyBlock()	101	if (!(action == null \|\| (action.isEmptyBlock()
98	&& currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3))) {	102	&& currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3))) {
99		103
100	if (!this.action.complainIfUnreachable(actionInfo, scope, false)) {	104	if (!this.action.complainIfUnreachable(actionInfo, scope, false)) {
101	actionInfo = action.analyseCode(scope, loopingContext, actionInfo);	105	actionInfo = action.
		106	analyseCode(scope, loopingContext, actionInfo).
		107	unconditionalCopy();
102	}	108	}
103		109
104	// code generation can be optimized when no need to continue in the loop	110	// code generation can be optimized when no need to continue in the loop
105	exitBranch = condInfo.initsWhenFalse();	111	exitBranch = flowInfo.unconditionalCopy().
106	exitBranch.addInitializationsFrom(flowInfo); // recover null inits from before condition analysis	112	addInitializationsFrom(condInfo.initsWhenFalse());
107	if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {	113	if (!actionInfo.isReachable() && !loopingContext.initsOnContinue.isReachable()) {
108	continueLabel = null;	114	continueLabel = null;
109	} else {	115	} else {
110	actionInfo = actionInfo.mergedWith(loopingContext.initsOnContinue.unconditionalInits());	116	actionInfo = actionInfo.mergedWith(loopingContext.initsOnContinue);
111	loopingContext.complainOnDeferredChecks(scope, actionInfo);	117	loopingContext.complainOnDeferredFinalChecks(scope, actionInfo);
112	exitBranch.addPotentialInitializationsFrom(actionInfo.unconditionalInits());	118	exitBranch.addPotentialInitializationsFrom(actionInfo);
113	}	119	}
114	} else {	120	} else {
115	exitBranch = condInfo.initsWhenFalse();	121	exitBranch = condInfo.initsWhenFalse();
Lines 133-138 Link Here
133	}	139	}
134	}	140	}
135	//end of loop	141	//end of loop
		142	loopingContext.complainOnDeferredNullChecks(currentScope, actionInfo);
		143
136	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranches(	144	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranches(
137	loopingContext.initsOnBreak,	145	loopingContext.initsOnBreak,
138	false,	146	false,

Lines 31-47 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/InstanceOfExpression.java (-7 / +8 lines)
31	this.sourceEnd = type.sourceEnd;	31	this.sourceEnd = type.sourceEnd;
32	}	32	}
33		33
34	public FlowInfo analyseCode(	34	public FlowInfo analyseCode(
35	BlockScope currentScope,	35	BlockScope currentScope,
36	FlowContext flowContext,	36	FlowContext flowContext,
37	FlowInfo flowInfo) {	37	FlowInfo flowInfo) {
38		38	LocalVariableBinding local = this.expression.localVariableBinding();
39	flowInfo = expression	39	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
40	.analyseCode(currentScope, flowContext, flowInfo)	40	flowContext.recordUsingNullReference(currentScope, local,
41	.unconditionalInits();	41	this.expression, FlowContext.CAN_ONLY_NULL, flowInfo);
42	expression.checkNullStatus(currentScope, flowContext, flowInfo, FlowInfo.NON_NULL);
43	return flowInfo;
44	}	42	}
		43	return expression.analyseCode(currentScope, flowContext, flowInfo).
		44	unconditionalInits();
		45	}
45		46
46	/**	47	/**
47	* Code generation for instanceOfExpression	48	* Code generation for instanceOfExpression

Lines 32-56 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-19 / +19 lines)
32	this.declarationEnd = sourceEnd;	32	this.declarationEnd = sourceEnd;
33	}	33	}
34		34
35	public FlowInfo analyseCode(	35	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
36	BlockScope currentScope,
37	FlowContext flowContext,
38	FlowInfo flowInfo) {	36	FlowInfo flowInfo) {
39		37	// record variable initialization if any
40	// record variable initialization if any	38	if (flowInfo.isReachable()) {
41	if (flowInfo.isReachable()) {	39	bits \|= IsLocalDeclarationReachable; // only set if actually reached
42	bits \|= IsLocalDeclarationReachable; // only set if actually reached	40	}
43	}	41	if (this.initialization == null) {
44	if (this.initialization == null)	42	return flowInfo;
45	return flowInfo;	43	}
46		44	int nullStatus = this.initialization.nullStatus(flowInfo);
47	int nullStatus = this.initialization.nullStatus(flowInfo);	45	flowInfo =
48	flowInfo =	46	this.initialization
49	this.initialization	47	.analyseCode(currentScope, flowContext, flowInfo)
50	.analyseCode(currentScope, flowContext, flowInfo)	48	.unconditionalInits();
51	.unconditionalInits();	49	flowInfo.markAsDefinitelyAssigned(binding);
52		50	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {
53	flowInfo.markAsDefinitelyAssigned(binding);
54	switch(nullStatus) {	51	switch(nullStatus) {
55	case FlowInfo.NULL :	52	case FlowInfo.NULL :
56	flowInfo.markAsDefinitelyNull(this.binding);	53	flowInfo.markAsDefinitelyNull(this.binding);
Lines 58-66 Link Here
58	case FlowInfo.NON_NULL :	55	case FlowInfo.NON_NULL :
59	flowInfo.markAsDefinitelyNonNull(this.binding);	56	flowInfo.markAsDefinitelyNonNull(this.binding);
60	break;	57	break;
		58	default:
		59	flowInfo.markAsDefinitelyUnknown(this.binding);
61	}	60	}
62	return flowInfo;
63	}	61	}
		62	return flowInfo;
		63	}
64		64
65	public void checkModifiers() {	65	public void checkModifiers() {
66		66

Lines 98-104 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-3 / +24 lines)
98	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {	98	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
99	localBinding.useFlag = LocalVariableBinding.FAKE_USED;	99	localBinding.useFlag = LocalVariableBinding.FAKE_USED;
100	}	100	}
101	this.checkNullStatus(currentScope, flowContext, flowInfo, FlowInfo.NON_NULL);	101	checkNPE(currentScope, flowContext, flowInfo, true);
102	}	102	}
103		103
104	if (needValue) {	104	if (needValue) {
Lines 257-263 Link Here
257	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {	257	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
258	localBinding.useFlag = LocalVariableBinding.FAKE_USED;	258	localBinding.useFlag = LocalVariableBinding.FAKE_USED;
259	}	259	}
260	this.checkNullStatus(currentScope, flowContext, flowInfo, FlowInfo.NON_NULL);	260	checkNPE(currentScope, flowContext, flowInfo, true);
261	}	261	}
262	if (needValue) {	262	if (needValue) {
263	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);	263	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
Lines 304-310 Link Here
304	bits \|= Binding.FIELD;	304	bits \|= Binding.FIELD;
305	return getOtherFieldBindings(scope);	305	return getOtherFieldBindings(scope);
306	}	306	}
307		307
		308	public void checkNPE(BlockScope scope, FlowContext flowContext,
		309	FlowInfo flowInfo, boolean checkString) {
		310	// cannot override localVariableBinding because this would project o.m onto o when
		311	// analysing assignments
		312	if ((bits & RestrictiveFlagMASK) == Binding.LOCAL) {
		313	LocalVariableBinding local = (LocalVariableBinding) this.binding;
		314	if (local != null &&
		315	(local.type.tagBits & TagBits.IsBaseType) == 0 &&
		316	(checkString \|\| local.type.id != T_JavaLangString)) {
		317	flowContext.recordUsingNullReference(scope, local, this,
		318	FlowContext.MAY_NULL, flowInfo);
		319	flowInfo.markAsComparedEqualToNonNull(local);
		320	// from thereon it is set
		321	}
		322	}
		323	}
308	/**	324	/**
309	* @see org.eclipse.jdt.internal.compiler.ast.Expression#computeConversion(org.eclipse.jdt.internal.compiler.lookup.Scope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding, org.eclipse.jdt.internal.compiler.lookup.TypeBinding)	325	* @see org.eclipse.jdt.internal.compiler.ast.Expression#computeConversion(org.eclipse.jdt.internal.compiler.lookup.Scope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding, org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
310	*/	326	*/
Lines 773-778 Link Here
773	? type.capture(scope, this.sourceEnd)	789	? type.capture(scope, this.sourceEnd)
774	: type;	790	: type;
775	}	791	}
		792
776	public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {	793	public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
777	if (!flowInfo.isReachable()) return;	794	if (!flowInfo.isReachable()) return;
778	//If inlinable field, forget the access emulation, the code gen will directly target it	795	//If inlinable field, forget the access emulation, the code gen will directly target it
Lines 849-854 Link Here
849	}	866	}
850	}	867	}
851		868
		869	public int nullStatus(FlowInfo flowInfo) {
		870	return FlowInfo.UNKNOWN;
		871	}
		872
852	public Constant optimizedBooleanConstant() {	873	public Constant optimizedBooleanConstant() {
853		874
854	switch (this.resolvedType.id) {	875	switch (this.resolvedType.id) {

Lines 68-87 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Reference.java (-16 lines)
68	public abstract void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired);	68	public abstract void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired);
69		69
70	public abstract void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired);	70	public abstract void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired);
71
72	public int nullStatus(FlowInfo flowInfo) {
73
74	if (this.constant != null && this.constant != Constant.NotAConstant)
75	return FlowInfo.NON_NULL; // constant expression cannot be null
76
77	LocalVariableBinding local = localVariableBinding();
78	if (local != null) {
79	if (flowInfo.isDefinitelyNull(local))
80	return FlowInfo.NULL;
81	if (flowInfo.isDefinitelyNonNull(local))
82	return FlowInfo.NON_NULL;
83	}
84	return FlowInfo.UNKNOWN;
85	}
86
87	}	71	}

Lines 634-640 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java (-4 / +4 lines)
634	* Common flow analysis for all types	634	* Common flow analysis for all types
635	*	635	*
636	*/	636	*/
637	public void internalAnalyseCode(FlowContext flowContext, FlowInfo flowInfo) {	637	private void internalAnalyseCode(FlowContext flowContext, FlowInfo flowInfo) {
638		638
639	if ((this.binding.isPrivate()/* \|\| (this.binding.tagBits & (TagBits.IsAnonymousType\|TagBits.IsLocalType)) == TagBits.IsLocalType*/) && !this.binding.isUsed()) {	639	if ((this.binding.isPrivate()/* \|\| (this.binding.tagBits & (TagBits.IsAnonymousType\|TagBits.IsLocalType)) == TagBits.IsLocalType*/) && !this.binding.isUsed()) {
640	if (!scope.referenceCompilationUnit().compilationResult.hasSyntaxError) {	640	if (!scope.referenceCompilationUnit().compilationResult.hasSyntaxError) {
Lines 644-651 Link Here
644		644
645	InitializationFlowContext initializerContext = new InitializationFlowContext(null, this, initializerScope);	645	InitializationFlowContext initializerContext = new InitializationFlowContext(null, this, initializerScope);
646	InitializationFlowContext staticInitializerContext = new InitializationFlowContext(null, this, staticInitializerScope);	646	InitializationFlowContext staticInitializerContext = new InitializationFlowContext(null, this, staticInitializerScope);
647	FlowInfo nonStaticFieldInfo = flowInfo.copy().unconditionalInits().discardFieldInitializations();	647	FlowInfo nonStaticFieldInfo = flowInfo.unconditionalFieldLessCopy();
648	FlowInfo staticFieldInfo = flowInfo.copy().unconditionalInits().discardFieldInitializations();	648	FlowInfo staticFieldInfo = flowInfo.unconditionalFieldLessCopy();
649	if (fields != null) {	649	if (fields != null) {
650	for (int i = 0, count = fields.length; i < count; i++) {	650	for (int i = 0, count = fields.length; i < count; i++) {
651	FieldDeclaration field = fields[i];	651	FieldDeclaration field = fields[i];
Lines 699-705 Link Here
699	}	699	}
700	}	700	}
701	if (methods != null) {	701	if (methods != null) {
702	UnconditionalFlowInfo outerInfo = flowInfo.copy().unconditionalInits().discardFieldInitializations();	702	UnconditionalFlowInfo outerInfo = flowInfo.unconditionalFieldLessCopy();
703	FlowInfo constructorInfo = nonStaticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo);	703	FlowInfo constructorInfo = nonStaticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo);
704	for (int i = 0, count = methods.length; i < count; i++) {	704	for (int i = 0, count = methods.length; i < count; i++) {
705	AbstractMethodDeclaration method = methods[i];	705	AbstractMethodDeclaration method = methods[i];

Lines 27-45 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/UnaryExpression.java (-9 / +10 lines)
27	this.bits \|= operator << OperatorSHIFT; // encode operator	27	this.bits \|= operator << OperatorSHIFT; // encode operator
28	}	28	}
29		29
30	public FlowInfo analyseCode(	30	public FlowInfo analyseCode(
31	BlockScope currentScope,	31	BlockScope currentScope,
32	FlowContext flowContext,	32	FlowContext flowContext,
33	FlowInfo flowInfo) {	33	FlowInfo flowInfo) {
34		34	this.expression.checkNPE(currentScope, flowContext, flowInfo, true);
35	if (((bits & OperatorMASK) >> OperatorSHIFT) == NOT) {	35	if (((bits & OperatorMASK) >> OperatorSHIFT) == NOT) {
36	return this.expression	36	return this.expression.
37	.analyseCode(currentScope, flowContext, flowInfo)	37	analyseCode(currentScope, flowContext, flowInfo).
38	.asNegatedCondition();	38	asNegatedCondition();
39	} else {	39	} else {
40	return this.expression.analyseCode(currentScope, flowContext, flowInfo);	40	return this.expression.
41	}	41	analyseCode(currentScope, flowContext, flowInfo);
42	}	42	}
		43	}
43		44
44	public Constant optimizedBooleanConstant() {	45	public Constant optimizedBooleanConstant() {
45		46

Lines 83-134 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/ConditionalFlowInfo.java (-85 / +93 lines)
83	&& initsWhenFalse.isDefinitelyAssigned(local);	83	&& initsWhenFalse.isDefinitelyAssigned(local);
84	}	84	}
85		85
86	/**	86	public boolean isDefinitelyNonNull(LocalVariableBinding local) {
87	* Check status of definite non-null assignment for a field.	87	return initsWhenTrue.isDefinitelyNonNull(local)
88	*/	88	&& initsWhenFalse.isDefinitelyNonNull(local);
89	public boolean isDefinitelyNonNull(FieldBinding field) {	89	}
90
91	return initsWhenTrue.isDefinitelyNonNull(field)
92	&& initsWhenFalse.isDefinitelyNonNull(field);
93	}
94
95	/**
96	* Check status of definite non-null assignment for a local variable.
97	*/
98	public boolean isDefinitelyNonNull(LocalVariableBinding local) {
99
100	return initsWhenTrue.isDefinitelyNonNull(local)
101	&& initsWhenFalse.isDefinitelyNonNull(local);
102	}
103		90
104	/**	91	public boolean isDefinitelyNull(LocalVariableBinding local) {
105	* Check status of definite null assignment for a field.	92	return initsWhenTrue.isDefinitelyNull(local)
106	*/	93	&& initsWhenFalse.isDefinitelyNull(local);
107	public boolean isDefinitelyNull(FieldBinding field) {	94	}
108
109	return initsWhenTrue.isDefinitelyNull(field)
110	&& initsWhenFalse.isDefinitelyNull(field);
111	}
112
113	/**
114	* Check status of definite null assignment for a local variable.
115	*/
116	public boolean isDefinitelyNull(LocalVariableBinding local) {
117
118	return initsWhenTrue.isDefinitelyNull(local)
119	&& initsWhenFalse.isDefinitelyNull(local);
120	}
121		95
122	public int reachMode(){	96	public boolean isDefinitelyUnknown(LocalVariableBinding local) {
123	return unconditionalInits().reachMode();	97	return initsWhenTrue.isDefinitelyUnknown(local)
124	}	98	&& initsWhenFalse.isDefinitelyUnknown(local);
125		99	}
126	public boolean isReachable(){
127
128	return unconditionalInits().isReachable();
129	//should maybe directly be: false
130	}
131
132	/**	100	/**
133	* Check status of potential assignment for a field.	101	* Check status of potential assignment for a field.
134	*/	102	*/
Lines 147-152 Link Here
147	\|\| initsWhenFalse.isPotentiallyAssigned(local);	115	\|\| initsWhenFalse.isPotentiallyAssigned(local);
148	}	116	}
149		117
		118	public boolean isPotentiallyNull(LocalVariableBinding local) {
		119	return initsWhenTrue.isPotentiallyNull(local)
		120	\|\| initsWhenFalse.isPotentiallyNull(local);
		121	}
		122
		123	public boolean isPotentiallyUnknown(LocalVariableBinding local) {
		124	return initsWhenTrue.isPotentiallyUnknown(local)
		125	\|\| initsWhenFalse.isPotentiallyUnknown(local);
		126	}
		127
		128	public boolean isProtectedNonNull(LocalVariableBinding local) {
		129	return initsWhenTrue.isProtectedNonNull(local)
		130	&& initsWhenFalse.isProtectedNonNull(local);
		131	}
		132
		133	public boolean isProtectedNull(LocalVariableBinding local) {
		134	return initsWhenTrue.isProtectedNull(local)
		135	&& initsWhenFalse.isProtectedNull(local);
		136	}
		137
		138	public void markAsComparedEqualToNonNull(LocalVariableBinding local) {
		139	initsWhenTrue.markAsComparedEqualToNonNull(local);
		140	initsWhenFalse.markAsComparedEqualToNonNull(local);
		141	}
		142
		143	public void markAsComparedEqualToNull(LocalVariableBinding local) {
		144	initsWhenTrue.markAsComparedEqualToNull(local);
		145	initsWhenFalse.markAsComparedEqualToNull(local);
		146	}
		147
150	/**	148	/**
151	* Record a field got definitely assigned.	149	* Record a field got definitely assigned.
152	*/	150	*/
Lines 201-250 Link Here
201	initsWhenFalse.markAsDefinitelyNull(local);	199	initsWhenFalse.markAsDefinitelyNull(local);
202	}	200	}
203		201
204	/**	202	public void markAsDefinitelyUnknown(LocalVariableBinding local) {
205	* Clear the initialization info for a field	203	initsWhenTrue.markAsDefinitelyUnknown(local);
206	*/	204	initsWhenFalse.markAsDefinitelyUnknown(local);
207	public void markAsDefinitelyNotAssigned(FieldBinding field) {	205	}
208		206
209	initsWhenTrue.markAsDefinitelyNotAssigned(field);	207	public FlowInfo setReachMode(int reachMode) {
210	initsWhenFalse.markAsDefinitelyNotAssigned(field);	208	if (reachMode == REACHABLE) {
211	}	209	this.tagBits &= ~UNREACHABLE;
212		210	}
213	/**	211	else {
214	* Clear the initialization info for a local variable	212	this.tagBits \|= UNREACHABLE;
215	*/	213	}
216	public void markAsDefinitelyNotAssigned(LocalVariableBinding local) {	214	initsWhenTrue.setReachMode(reachMode);
217		215	initsWhenFalse.setReachMode(reachMode);
218	initsWhenTrue.markAsDefinitelyNotAssigned(local);	216	return this;
219	initsWhenFalse.markAsDefinitelyNotAssigned(local);	217	}
220	}
221
222	public FlowInfo setReachMode(int reachMode) {
223
224	initsWhenTrue.setReachMode(reachMode);
225	initsWhenFalse.setReachMode(reachMode);
226	return this;
227	}
228
229	/**
230	* Converts conditional receiver into inconditional one, updated in the following way: <ul>
231	* <li> intersection of definitely assigned variables,
232	* <li> union of potentially assigned variables.
233	* </ul>
234	*/
235	public UnconditionalFlowInfo mergedWith(UnconditionalFlowInfo otherInits) {
236
237	return unconditionalInits().mergedWith(otherInits);
238	}
239		218
		219	public UnconditionalFlowInfo mergedWith(UnconditionalFlowInfo otherInits) {
		220	return unconditionalInits().mergedWith(otherInits);
		221	}
		222
		223	public UnconditionalFlowInfo nullInfoLessUnconditionalCopy() {
		224	return unconditionalInitsWithoutSideEffect().
		225	nullInfoLessUnconditionalCopy();
		226	}
240	public String toString() {	227	public String toString() {
241		228
242	return "FlowInfo<true: " + initsWhenTrue.toString() + ", false: " + initsWhenFalse.toString() + ">"; //$NON-NLS-1$ //$NON-NLS-3$ //$NON-NLS-2$	229	return "FlowInfo<true: " + initsWhenTrue.toString() + ", false: " + initsWhenFalse.toString() + ">"; //$NON-NLS-1$ //$NON-NLS-3$ //$NON-NLS-2$
243	}	230	}
244		231
245	public UnconditionalFlowInfo unconditionalInits() {	232	public FlowInfo safeInitsWhenTrue() {
246		233	return initsWhenTrue;
247	return initsWhenTrue.unconditionalInits().copy()	234	}
248	.mergedWith(initsWhenFalse.unconditionalInits());	235
249	}	236	public UnconditionalFlowInfo unconditionalCopy() {
		237	return initsWhenTrue.unconditionalCopy().
		238	mergedWith(initsWhenFalse.unconditionalInits());
		239	}
		240
		241	public UnconditionalFlowInfo unconditionalFieldLessCopy() {
		242	return initsWhenTrue.unconditionalFieldLessCopy().
		243	mergedWith(initsWhenFalse.unconditionalFieldLessCopy());
		244	// should never happen, hence suboptimal does not hurt
		245	}
		246
		247	public UnconditionalFlowInfo unconditionalInits() {
		248	return initsWhenTrue.unconditionalInits().
		249	mergedWith(initsWhenFalse.unconditionalInits());
		250	}
		251
		252	public UnconditionalFlowInfo unconditionalInitsWithoutSideEffect() {
		253	// cannot do better here than unconditionalCopy - but still a different
		254	// operation for UnconditionalFlowInfo
		255	return initsWhenTrue.unconditionalCopy().
		256	mergedWith(initsWhenFalse.unconditionalInits());
		257	}
250	}	258	}

Lines 62-68 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/ExceptionHandlingFlowContext.java (-12 / +14 lines)
62	int cacheIndex = i / BitCacheSize, bitMask = 1 << (i % BitCacheSize);	62	int cacheIndex = i / BitCacheSize, bitMask = 1 << (i % BitCacheSize);
63	if (handledExceptions[i].isUncheckedException(true)) {	63	if (handledExceptions[i].isUncheckedException(true)) {
64	isReached[cacheIndex] \|= bitMask;	64	isReached[cacheIndex] \|= bitMask;
65	this.initsOnExceptions[i] = flowInfo.copy().unconditionalInits();	65	this.initsOnExceptions[i] = flowInfo.unconditionalCopy();
66	} else {	66	} else {
67	this.initsOnExceptions[i] = FlowInfo.DEAD_END;	67	this.initsOnExceptions[i] = FlowInfo.DEAD_END;
68	}	68	}
Lines 168-187 Link Here
168	this.isReached[cacheIndex] \|= bitMask;	168	this.isReached[cacheIndex] \|= bitMask;
169		169
170	initsOnExceptions[index] =	170	initsOnExceptions[index] =
171	initsOnExceptions[index] == FlowInfo.DEAD_END	171	initsOnExceptions[index].isReachable() ?
172	? flowInfo.copy().unconditionalInits()	172	initsOnExceptions[index].mergedWith(flowInfo):
173	: initsOnExceptions[index].mergedWith(flowInfo.copy().unconditionalInits());	173	flowInfo.unconditionalCopy();
174	}	174	}
175		175
176	public void recordReturnFrom(FlowInfo flowInfo) {	176	public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {
177		177	if (!flowInfo.isReachable()) {
178	if (!flowInfo.isReachable()) return;	178	return;
179	if (initsOnReturn == FlowInfo.DEAD_END) {	179	}
180	initsOnReturn = flowInfo.copy().unconditionalInits();	180	if (initsOnReturn.isReachable()) {
181	} else {	181	initsOnReturn = initsOnReturn.mergedWith(flowInfo);
182	initsOnReturn = initsOnReturn.mergedWith(flowInfo.copy().unconditionalInits());	182	}
183	}	183	else {
		184	initsOnReturn = (UnconditionalFlowInfo) flowInfo.copy();
184	}	185	}
		186	}
185		187
186	/*	188	/*
187	* Compute a merged list of unhandled exception types (keeping only the most generic ones).	189	* Compute a merged list of unhandled exception types (keeping only the most generic ones).

Lines 15-22 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/FlowInfo.java (-69 / +234 lines)
15		15
16	public abstract class FlowInfo {	16	public abstract class FlowInfo {
17		17
		18	public int tagBits; // REACHABLE by default
18	public final static int REACHABLE = 0;	19	public final static int REACHABLE = 0;
19	public final static int UNREACHABLE = 1;	20	public final static int UNREACHABLE = 1;
		21	public final static int NULL_FLAG_MASK = 2;
20		22
21	public final static int UNKNOWN = 0;	23	public final static int UNKNOWN = 0;
22	public final static int NULL = 1;	24	public final static int NULL = 1;
Lines 25-35 Link Here
25	public static final UnconditionalFlowInfo DEAD_END; // Represents a dead branch status of initialization	27	public static final UnconditionalFlowInfo DEAD_END; // Represents a dead branch status of initialization
26	static {	28	static {
27	DEAD_END = new UnconditionalFlowInfo();	29	DEAD_END = new UnconditionalFlowInfo();
28	DEAD_END.reachMode = UNREACHABLE;	30	DEAD_END.tagBits = UNREACHABLE;
29	}	31	}
30	abstract public FlowInfo addInitializationsFrom(FlowInfo otherInits);
31		32
32	abstract public FlowInfo addPotentialInitializationsFrom(FlowInfo otherInits);	33	/**
		34	* Add other inits to this flow info, then return this. The operation semantics
		35	* are to match as closely as possible the application to this flow info of all
		36	* the operations that resulted into otherInits.
		37	* @param otherInits other inits to add to this
		38	* @return this, modified according to otherInits information
		39	*/
		40	abstract public FlowInfo addInitializationsFrom(FlowInfo otherInits);
		41
		42
		43	/**
		44	* Compose other inits over this flow info, then return this. The operation
		45	* semantics are to wave into this flow info the consequences of a possible
		46	* path into the operations that resulted into otherInits. The fact that this
		47	* path may be left unexecuted under peculiar conditions results into less
		48	* specific results than {@link #addInitializationsFrom(FlowInfo)
		49	* addInitializationsFrom}.
		50	* @param otherInits other inits to compose over this
		51	* @return this, modified according to otherInits information
		52	*/
		53	abstract public FlowInfo addPotentialInitializationsFrom(FlowInfo otherInits);
33		54
34	public FlowInfo asNegatedCondition() {	55	public FlowInfo asNegatedCondition() {
35		56
Lines 42-47 Link Here
42	return new ConditionalFlowInfo(initsWhenTrue, initsWhenFalse);	63	return new ConditionalFlowInfo(initsWhenTrue, initsWhenFalse);
43	}	64	}
44		65
		66	/**
		67	* Return a deep copy of the current instance.
		68	* @return a deep copy of this flow info
		69	*/
45	abstract public FlowInfo copy();	70	abstract public FlowInfo copy();
46		71
47	public static UnconditionalFlowInfo initial(int maxFieldCount) {	72	public static UnconditionalFlowInfo initial(int maxFieldCount) {
Lines 49-57 Link Here
49	info.maxFieldCount = maxFieldCount;	74	info.maxFieldCount = maxFieldCount;
50	return info;	75	return info;
51	}	76	}
52		77
53	abstract public FlowInfo initsWhenFalse();	78	/**
54		79	* Return the flow info that would result from the path associated to the
		80	* value false for the condition expression that generated this flow info.
		81	* May be this flow info if it is not an instance of {@link
		82	* ConditionalFlowInfo}. May have a side effect on subparts of this flow
		83	* info (subtrees get merged).
		84	* @return the flow info associated to the false branch of the condition
		85	* that generated this flow info
		86	*/
		87	abstract public FlowInfo initsWhenFalse();
		88
		89	/**
		90	* Return the flow info that would result from the path associated to the
		91	* value true for the condition expression that generated this flow info.
		92	* May be this flow info if it is not an instance of {@link
		93	* ConditionalFlowInfo}. May have a side effect on subparts of this flow
		94	* info (subtrees get merged).
		95	* @return the flow info associated to the true branch of the condition
		96	* that generated this flow info
		97	*/
55	abstract public FlowInfo initsWhenTrue();	98	abstract public FlowInfo initsWhenTrue();
56		99
57	/**	100	/**
Lines 64-88 Link Here
64	*/	107	*/
65	public abstract boolean isDefinitelyAssigned(LocalVariableBinding local);	108	public abstract boolean isDefinitelyAssigned(LocalVariableBinding local);
66		109
67	/**	110	/**
68	* Check status of definite null assignment for a field.	111	* Check status of definite non-null value for a given local variable.
69	*/	112	* @param local the variable to ckeck
70	abstract public boolean isDefinitelyNonNull(FieldBinding field);	113	* @return true iff local is definitely non null for this flow info
71		114	*/
72	/**
73	* Check status of definite null assignment for a local.
74	*/
75	public abstract boolean isDefinitelyNonNull(LocalVariableBinding local);	115	public abstract boolean isDefinitelyNonNull(LocalVariableBinding local);
76		116
77	/**	117	/**
78	* Check status of definite null assignment for a field.	118	* Check status of definite null value for a given local variable.
79	*/	119	* @param local the variable to ckeck
80	abstract public boolean isDefinitelyNull(FieldBinding field);	120	* @return true iff local is definitely null for this flow info
81		121	*/
82	/**	122	public abstract boolean isDefinitelyNull(LocalVariableBinding local);
83	* Check status of definite null assignment for a local.	123
84	*/	124	/**
85	public abstract boolean isDefinitelyNull(LocalVariableBinding local);	125	* Check status of definite unknown value for a given local variable.
		126	* @param local the variable to ckeck
		127	* @return true iff local is definitely unknown for this flow info
		128	*/
		129	public abstract boolean isDefinitelyUnknown(LocalVariableBinding local);
86		130
87	/**	131	/**
88	* Check status of potential assignment for a field.	132	* Check status of potential assignment for a field.
Lines 95-101 Link Here
95		139
96	abstract public boolean isPotentiallyAssigned(LocalVariableBinding field);	140	abstract public boolean isPotentiallyAssigned(LocalVariableBinding field);
97		141
98	abstract public boolean isReachable();	142	/**
		143	* Check status of potential null assignment for a local.
		144	*/
		145	public abstract boolean isPotentiallyNull(LocalVariableBinding local);
		146
		147	/**
		148	* Return true if the given local may have been assigned to an unknown value.
		149	* @param local the local to check
		150	* @return true if the given local may have been assigned to an unknown value
		151	*/
		152	public abstract boolean isPotentiallyUnknown(LocalVariableBinding local);
		153
		154	/**
		155	* Return true if the given local is protected by a test against a non null
		156	* value.
		157	* @param local the local to check
		158	* @return true if the given local is protected by a test against a non null
		159	*/
		160	public abstract boolean isProtectedNonNull(LocalVariableBinding local);
		161
		162	/**
		163	* Return true if the given local is protected by a test against null.
		164	* @param local the local to check
		165	* @return true if the given local is protected by a test against null
		166	*/
		167	public abstract boolean isProtectedNull(LocalVariableBinding local);
		168
		169	public boolean isReachable() {
		170	return (this.tagBits & UNREACHABLE) == 0;
		171	}
		172
		173	/**
		174	* Record that a local variable got checked to be non null.
		175	* @param local the checked local variable
		176	*/
		177	abstract public void markAsComparedEqualToNonNull(LocalVariableBinding local);
		178
		179	/**
		180	* Record that a local variable got checked to be null.
		181	* @param local the checked local variable
		182	*/
		183	abstract public void markAsComparedEqualToNull(LocalVariableBinding local);
99		184
100	/**	185	/**
101	* Record a field got definitely assigned.	186	* Record a field got definitely assigned.
Lines 118-124 Link Here
118	abstract public void markAsDefinitelyNull(LocalVariableBinding local);	203	abstract public void markAsDefinitelyNull(LocalVariableBinding local);
119		204
120	/**	205	/**
121	* Record a field got definitely assigned.	206	* Record a field got definitely assigned to null.
122	*/	207	*/
123	abstract public void markAsDefinitelyNull(FieldBinding field);	208	abstract public void markAsDefinitelyNull(FieldBinding field);
124		209
Lines 127-178 Link Here
127	*/	212	*/
128	abstract public void markAsDefinitelyAssigned(LocalVariableBinding local);	213	abstract public void markAsDefinitelyAssigned(LocalVariableBinding local);
129		214
130	/**	215	/**
131	* Clear the initialization info for a field	216	* Record a local got definitely assigned to an unknown value.
132	*/	217	*/
133	abstract public void markAsDefinitelyNotAssigned(FieldBinding field);	218	abstract public void markAsDefinitelyUnknown(LocalVariableBinding local);
134		219
135	/**	220	/**
136	* Clear the initialization info for a local variable	221	* Merge branches using optimized boolean conditions
137	*/	222	*/
138	abstract public void markAsDefinitelyNotAssigned(LocalVariableBinding local);	223	public static UnconditionalFlowInfo mergedOptimizedBranches(
139		224	FlowInfo initsWhenTrue, boolean isOptimizedTrue,
140	/**	225	FlowInfo initsWhenFalse, boolean isOptimizedFalse,
141	* Merge branches using optimized boolean conditions	226	boolean allowFakeDeadBranch) {
142	*/	227	UnconditionalFlowInfo mergedInfo;
143	public static FlowInfo mergedOptimizedBranches(FlowInfo initsWhenTrue, boolean isOptimizedTrue, FlowInfo initsWhenFalse, boolean isOptimizedFalse, boolean allowFakeDeadBranch) {	228	if (isOptimizedTrue){
144	FlowInfo mergedInfo;	229	if (initsWhenTrue == FlowInfo.DEAD_END && allowFakeDeadBranch) {
145	if (isOptimizedTrue){	230	mergedInfo = initsWhenFalse.setReachMode(FlowInfo.UNREACHABLE).
146	if (initsWhenTrue == FlowInfo.DEAD_END && allowFakeDeadBranch) {	231	unconditionalInits();
147	mergedInfo = initsWhenFalse.setReachMode(FlowInfo.UNREACHABLE);	232	}
148	} else {	233	else {
149	mergedInfo = initsWhenTrue.addPotentialInitializationsFrom(initsWhenFalse);	234	mergedInfo =
150	}	235	initsWhenTrue.addPotentialInitializationsFrom(initsWhenFalse.
151		236	nullInfoLessUnconditionalCopy()).
152	} else if (isOptimizedFalse) {	237	unconditionalInits();
153	if (initsWhenFalse == FlowInfo.DEAD_END && allowFakeDeadBranch) {	238	}
154	mergedInfo = initsWhenTrue.setReachMode(FlowInfo.UNREACHABLE);	239	}
155	} else {	240	else if (isOptimizedFalse) {
156	mergedInfo = initsWhenFalse.addPotentialInitializationsFrom(initsWhenTrue);	241	if (initsWhenFalse == FlowInfo.DEAD_END && allowFakeDeadBranch) {
157	}	242	mergedInfo = initsWhenTrue.setReachMode(FlowInfo.UNREACHABLE).
158		243	unconditionalInits();
159	} else {	244	}
160	mergedInfo = initsWhenTrue.unconditionalInits().mergedWith(initsWhenFalse.unconditionalInits());	245	else {
		246	mergedInfo =
		247	initsWhenFalse.addPotentialInitializationsFrom(initsWhenTrue.
		248	nullInfoLessUnconditionalCopy()).
		249	unconditionalInits();
161	}	250	}
162	return mergedInfo;	251	}
		252	else {
		253	mergedInfo = initsWhenTrue.
		254	mergedWith(initsWhenFalse.unconditionalInits());
163	}	255	}
		256	return mergedInfo;
		257	}
164		258
165	abstract public int reachMode();	259	/**
166		260	* Return REACHABLE if this flow info is reachable, UNREACHABLE
167	abstract public FlowInfo setReachMode(int reachMode);	261	* else.
168		262	* @return REACHABLE if this flow info is reachable, UNREACHABLE
169	/**	263	* else
170	* Returns the receiver updated in the following way: <ul>	264	*/
171	* <li> intersection of definitely assigned variables,	265	public int reachMode() {
172	* <li> union of potentially assigned variables.	266	return this.tagBits & UNREACHABLE;
173	* </ul>	267	}
174	*/	268
175	abstract public UnconditionalFlowInfo mergedWith(UnconditionalFlowInfo otherInits);	269	/**
		270	* Return a flow info that carries the same information as the result of
		271	* {@link #initsWhenTrue() initsWhenTrue}, but warrantied to be different
		272	* from this.<br>
		273	* Caveat: side effects on the result may affect components of this.
		274	* @return the result of initsWhenTrue or a copy of it
		275	*/
		276	abstract public FlowInfo safeInitsWhenTrue();
		277
		278	/**
		279	* Set this flow info reach mode and return this.
		280	* @param reachMode one of {@link #REACHABLE REACHABLE} or {@link #UNREACHABLE UNREACHABLE}
		281	* @return this, with the reach mode set to reachMode
		282	*/
		283	abstract public FlowInfo setReachMode(int reachMode);
		284
		285	/**
		286	* Return the intersection of this and otherInits, that is
		287	* one of:<ul>
		288	* <li>the receiver updated in the following way:<ul>
		289	* <li>intersection of definitely assigned variables,
		290	* <li>union of potentially assigned variables,
		291	* <li>similar operations for null,</ul>
		292	* <li>or the receiver or otherInits if the other one is non
		293	* reachable.</ul>
		294	* otherInits is not affected, and is not returned either (no
		295	* need to protect the result).
		296	* @param otherInits the flow info to merge with this
		297	* @return the intersection of this and otherInits.
		298	*/
		299	abstract public UnconditionalFlowInfo mergedWith(
		300	UnconditionalFlowInfo otherInits);
		301
		302	/**
		303	* Return a copy of this unconditional flow info, deprived from its null
		304	* info. {@link #DEAD_END DEAD_END} is returned unmodified.
		305	* @return a copy of this unconditional flow info deprived from its null info
		306	*/
		307	abstract public UnconditionalFlowInfo nullInfoLessUnconditionalCopy();
176		308
177	public String toString(){	309	public String toString(){
178		310
Lines 182-186 Link Here
182	return super.toString();	314	return super.toString();
183	}	315	}
184		316
185	abstract public UnconditionalFlowInfo unconditionalInits();	317	/**
		318	* Return a new flow info that holds the same information as this would after
		319	* a call to unconditionalInits, but leaving this info unaffected. Moreover,
		320	* the result can be modified without affecting this.
		321	* @return a new flow info carrying this unconditional flow info
		322	*/
		323	abstract public UnconditionalFlowInfo unconditionalCopy();
		324
		325	/**
		326	* Return a new flow info that holds the same information as this would after
		327	* a call to {@link #unconditionalInits() unconditionalInits} followed by the
		328	* erasure of fields specific information, but leaving this flow info unaffected.
		329	* @return a new flow info carrying the unconditional flow info for local variables
		330	*/
		331	abstract public UnconditionalFlowInfo unconditionalFieldLessCopy();
		332
		333	/**
		334	* Return a flow info that merges the possible paths of execution described by
		335	* this flow info. In case of an unconditional flow info, return this. In case
		336	* of a conditional flow info, merge branches recursively. Caveat: this may
		337	* be affected, and modifying the result may affect this.
		338	* @return a flow info that merges the possible paths of execution described by
		339	* this
		340	*/
		341	abstract public UnconditionalFlowInfo unconditionalInits();
		342
		343	/**
		344	* Return a new flow info that holds the same information as this would after
		345	* a call to {@link #unconditionalInits() unconditionalInits}, but leaving
		346	* this info unaffected. Side effects on the result might affect this though
		347	* (consider it as read only).
		348	* @return a flow info carrying this unconditional flow info
		349	*/
		350	abstract public UnconditionalFlowInfo unconditionalInitsWithoutSideEffect();
186	}	351	}

Lines 47-59 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/InsideSubRoutineFlowContext.java (-8 / +9 lines)
47	return (SubRoutineStatement)associatedNode;	47	return (SubRoutineStatement)associatedNode;
48	}	48	}
49		49
50	public void recordReturnFrom(FlowInfo flowInfo) {	50	public void recordReturnFrom(UnconditionalFlowInfo flowInfo) {
51		51	if (!flowInfo.isReachable()) {
52	if (!flowInfo.isReachable()) return;	52	return;
53	if (initsOnReturn == FlowInfo.DEAD_END) {
54	initsOnReturn = flowInfo.copy().unconditionalInits();
55	} else {
56	initsOnReturn = initsOnReturn.mergedWith(flowInfo.copy().unconditionalInits());
57	}
58	}	53	}
		54	if (initsOnReturn == FlowInfo.DEAD_END) {
		55	initsOnReturn = (UnconditionalFlowInfo) flowInfo.copy();
		56	} else {
		57	initsOnReturn = initsOnReturn.mergedWith(flowInfo);
		58	}
		59	}
59	}	60	}

Lines 28-109 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/LoopingFlowContext.java (-65 / +226 lines)
28		28
29	public Label continueLabel;	29	public Label continueLabel;
30	public UnconditionalFlowInfo initsOnContinue = FlowInfo.DEAD_END;	30	public UnconditionalFlowInfo initsOnContinue = FlowInfo.DEAD_END;
		31	private UnconditionalFlowInfo upstreamNullFlowInfo;
		32	private LoopingFlowContext innerFlowContexts[] = null;
		33	private UnconditionalFlowInfo innerFlowInfos[] = null;
		34	private int innerFlowContextsNb = 0;
		35
31	Reference finalAssignments[];	36	Reference finalAssignments[];
32	VariableBinding finalVariables[];	37	VariableBinding finalVariables[];
33	int assignCount = 0;	38	int assignCount = 0;
34		39
		40	LocalVariableBinding[] nullLocals;
35	Expression[] nullReferences;	41	Expression[] nullReferences;
36	int[] nullStatus;	42	int[] nullCheckTypes;
37	int nullCount;	43	int nullCount;
38		44
39	Scope associatedScope;	45	Scope associatedScope;
40		46
41	public LoopingFlowContext(	47	public LoopingFlowContext(
42	FlowContext parent,	48	FlowContext parent,
		49	FlowInfo upstreamNullFlowInfo,
43	ASTNode associatedNode,	50	ASTNode associatedNode,
44	Label breakLabel,	51	Label breakLabel,
45	Label continueLabel,	52	Label continueLabel,
46	Scope associatedScope) {	53	Scope associatedScope) {
47	super(parent, associatedNode, breakLabel);	54	super(parent, associatedNode, breakLabel);
		55	preemptNullDiagnostic = true;
		56	// children will defer to this, which may defer to its own parent
48	this.continueLabel = continueLabel;	57	this.continueLabel = continueLabel;
49	this.associatedScope = associatedScope;	58	this.associatedScope = associatedScope;
		59	this.upstreamNullFlowInfo = upstreamNullFlowInfo.unconditionalCopy();
50	}	60	}
51		61
52	public void complainOnDeferredChecks(BlockScope scope, FlowInfo flowInfo) {	62	/**
53		63	* Perform deferred checks relative to final variables duplicate initialization
54	// complain on final assignments in loops	64	* of lack of initialization.
55	for (int i = 0; i < assignCount; i++) {	65	* @param scope the scope to which this context is associated
56	VariableBinding variable = finalVariables[i];	66	* @param flowInfo the flow info against which checks must be performed
57	if (variable == null) continue;	67	*/
58	boolean complained = false; // remember if have complained on this final assignment	68	public void complainOnDeferredFinalChecks(BlockScope scope, FlowInfo flowInfo) {
59	if (variable instanceof FieldBinding) {	69	// complain on final assignments in loops
60	if (flowInfo.isPotentiallyAssigned((FieldBinding) variable)) {	70	for (int i = 0; i < assignCount; i++) {
61	complained = true;	71	VariableBinding variable = finalVariables[i];
62	scope.problemReporter().duplicateInitializationOfBlankFinalField(	72	if (variable == null) continue;
63	(FieldBinding) variable,	73	boolean complained = false; // remember if have complained on this final assignment
64	finalAssignments[i]);	74	if (variable instanceof FieldBinding) {
65	}	75	if (flowInfo.isPotentiallyAssigned((FieldBinding) variable)) {
66	} else {	76	complained = true;
67	if (flowInfo.isPotentiallyAssigned((LocalVariableBinding) variable)) {	77	scope.problemReporter().duplicateInitializationOfBlankFinalField(
68	complained = true;	78	(FieldBinding) variable,
69	scope.problemReporter().duplicateInitializationOfFinalLocal(	79	finalAssignments[i]);
70	(LocalVariableBinding) variable,
71	finalAssignments[i]);
72	}
73	}	80	}
74	// any reference reported at this level is removed from the parent context where it	81	} else {
75	// could also be reported again	82	if (flowInfo.isPotentiallyAssigned((LocalVariableBinding) variable)) {
76	if (complained) {	83	complained = true;
77	FlowContext context = parent;	84	scope.problemReporter().duplicateInitializationOfFinalLocal(
78	while (context != null) {	85	(LocalVariableBinding) variable,
79	context.removeFinalAssignmentIfAny(finalAssignments[i]);	86	finalAssignments[i]);
80	context = context.parent;
81	}
82	}	87	}
83	}	88	}
84	// check inconsistent null checks	89	// any reference reported at this level is removed from the parent context where it
85	for (int i = 0; i < nullCount; i++) {	90	// could also be reported again
86	Expression expression = nullReferences[i];	91	if (complained) {
87	if (expression == null) continue;	92	FlowContext context = parent;
		93	while (context != null) {
		94	context.removeFinalAssignmentIfAny(finalAssignments[i]);
		95	context = context.parent;
		96	}
		97	}
		98	}
		99	}
		100
		101	/**
		102	* Perform deferred checks relative to the null status of local variables.
		103	* @param scope the scope to which this context is associated
		104	* @param flowInfo the flow info against which checks must be performed
		105	*/
		106	public void complainOnDeferredNullChecks(BlockScope scope, FlowInfo flowInfo) {
		107	for (int i = 0 ; i < this.innerFlowContextsNb ; i++) {
		108	this.upstreamNullFlowInfo.
		109	addPotentialNullInfoFrom(
		110	this.innerFlowContexts[i].upstreamNullFlowInfo).
		111	addPotentialNullInfoFrom(this.innerFlowInfos[i]);
		112	}
		113	this.innerFlowContextsNb = 0;
		114	flowInfo = this.upstreamNullFlowInfo.
		115	addPotentialNullInfoFrom(
		116	flowInfo.unconditionalInitsWithoutSideEffect());
		117	if (this.deferNullDiagnostic) {
		118	// check only immutable null checks on innermost looping context
		119	for (int i = 0; i < this.nullCount; i++) {
		120	LocalVariableBinding local = this.nullLocals[i];
		121	Expression expression = this.nullReferences[i];
88	// final local variable	122	// final local variable
89	LocalVariableBinding local = expression.localVariableBinding();	123	switch (this.nullCheckTypes[i]) {
90	switch (nullStatus[i]) {	124	case CAN_ONLY_NULL_NON_NULL :
91	case FlowInfo.NULL :	125	if (flowInfo.isDefinitelyNonNull(local)) {
		126	this.nullReferences[i] = null;
		127	scope.problemReporter().localVariableCannotBeNull(local, expression);
		128	continue;
		129	}
		130	case CAN_ONLY_NULL :
92	if (flowInfo.isDefinitelyNull(local)) {	131	if (flowInfo.isDefinitelyNull(local)) {
93	nullReferences[i] = null;	132	this.nullReferences[i] = null;
94	this.parent.recordUsingNullReference(scope, local, expression, nullStatus[i], flowInfo);	133	scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
		134	continue;
95	}	135	}
96	break;	136	break;
97	case FlowInfo.NON_NULL :	137	case MAY_NULL:
		138	if (flowInfo.isDefinitelyNull(local)) {
		139	this.nullReferences[i] = null;
		140	scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
		141	continue;
		142	}
		143	break;
		144	default:
		145	// never happens
		146	}
		147	this.parent.recordUsingNullReference(scope, local, expression,
		148	this.nullCheckTypes[i], flowInfo);
		149	}
		150	}
		151	else {
		152	// check inconsistent null checks on outermost looping context
		153	for (int i = 0; i < this.nullCount; i++) {
		154	Expression expression = this.nullReferences[i];
		155	// final local variable
		156	LocalVariableBinding local = this.nullLocals[i];
		157	switch (this.nullCheckTypes[i]) {
		158	case CAN_ONLY_NULL_NON_NULL :
98	if (flowInfo.isDefinitelyNonNull(local)) {	159	if (flowInfo.isDefinitelyNonNull(local)) {
99	nullReferences[i] = null;	160	this.nullReferences[i] = null;
100	this.parent.recordUsingNullReference(scope, local, expression, nullStatus[i], flowInfo);	161	scope.problemReporter().localVariableCannotBeNull(local, expression);
		162	continue;
		163	}
		164	case CAN_ONLY_NULL :
		165	if (flowInfo.isDefinitelyNull(local)) {
		166	this.nullReferences[i] = null;
		167	scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
		168	continue;
101	}	169	}
102	break;	170	break;
		171	case MAY_NULL:
		172	if (flowInfo.isDefinitelyNull(local)) {
		173	this.nullReferences[i] = null;
		174	scope.problemReporter().localVariableCanOnlyBeNull(local, expression);
		175	continue;
		176	}
		177	if (flowInfo.isPotentiallyNull(local)) {
		178	this.nullReferences[i] = null;
		179	scope.problemReporter().localVariableMayBeNull(local, expression);
		180	continue;
		181	}
		182	break;
		183	default:
		184	// never happens
103	}	185	}
104	}	186	}
105	}	187	}
106		188	}
		189
107	public Label continueLabel() {	190	public Label continueLabel() {
108	return continueLabel;	191	return continueLabel;
109	}	192	}
Lines 125-139 Link Here
125	return initsOnContinue != FlowInfo.DEAD_END;	208	return initsOnContinue != FlowInfo.DEAD_END;
126	}	209	}
127		210
128	public void recordContinueFrom(FlowInfo flowInfo) {	211	public void recordContinueFrom(FlowContext innerFlowContext, FlowInfo flowInfo) {
129		212	if (!flowInfo.isReachable()) {
130	if (!flowInfo.isReachable()) return;	213	return;
131	if (initsOnContinue == FlowInfo.DEAD_END) {	214	}
132	initsOnContinue = flowInfo.copy().unconditionalInits();	215	if (initsOnContinue.isReachable()) {
133	} else {	216	initsOnContinue = initsOnContinue.
134	initsOnContinue = initsOnContinue.mergedWith(flowInfo.copy().unconditionalInits());	217	mergedWith(flowInfo.unconditionalInitsWithoutSideEffect());
		218	}
		219	else {
		220	initsOnContinue = flowInfo.unconditionalCopy();
		221	}
		222	FlowContext inner = innerFlowContext;
		223	while (inner != this && !(inner instanceof LoopingFlowContext)) {
		224	inner = inner.parent;
		225	}
		226	if (inner == this) {
		227	this.upstreamNullFlowInfo.
		228	addPotentialNullInfoFrom(
		229	flowInfo.unconditionalInitsWithoutSideEffect());
		230	}
		231	else {
		232	int length = 0;
		233	if (this.innerFlowContexts == null) {
		234	this.innerFlowContexts = new LoopingFlowContext[5];
		235	this.innerFlowInfos = new UnconditionalFlowInfo[5];
135	}	236	}
		237	else if (this.innerFlowContextsNb ==
		238	(length = this.innerFlowContexts.length) - 1) {
		239	System.arraycopy(this.innerFlowContexts, 0,
		240	(this.innerFlowContexts = new LoopingFlowContext[length + 5]),
		241	0, length);
		242	System.arraycopy(this.innerFlowInfos, 0,
		243	(this.innerFlowInfos= new UnconditionalFlowInfo[length + 5]),
		244	0, length);
		245	}
		246	this.innerFlowContexts[this.innerFlowContextsNb] = (LoopingFlowContext) inner;
		247	this.innerFlowInfos[this.innerFlowContextsNb++] =
		248	flowInfo.unconditionalInitsWithoutSideEffect();
136	}	249	}
		250	}
137		251
138	protected boolean recordFinalAssignment(	252	protected boolean recordFinalAssignment(
139	VariableBinding binding,	253	VariableBinding binding,
Lines 170-189 Link Here
170	return true;	284	return true;
171	}	285	}
172		286
173	protected boolean recordNullReference(Expression expression, int status) {	287	protected void recordNullReference(LocalVariableBinding local,
174	if (nullCount == 0) {	288	Expression expression, int status) {
175	nullReferences = new Expression[5];	289	if (nullCount == 0) {
176	nullStatus = new int[5];	290	nullLocals = new LocalVariableBinding[5];
177	} else {	291	nullReferences = new Expression[5];
178	if (nullCount == nullReferences.length) {	292	nullCheckTypes = new int[5];
179	System.arraycopy(nullReferences, 0, nullReferences = new Expression[nullCount * 2], 0, nullCount);	293	}
180	System.arraycopy(nullStatus, 0, nullStatus = new int[nullCount * 2], 0, nullCount);	294	else if (nullCount == nullLocals.length) {
		295	System.arraycopy(nullLocals, 0,
		296	nullLocals = new LocalVariableBinding[nullCount * 2], 0, nullCount);
		297	System.arraycopy(nullReferences, 0,
		298	nullReferences = new Expression[nullCount * 2], 0, nullCount);
		299	System.arraycopy(nullCheckTypes, 0,
		300	nullCheckTypes = new int[nullCount * 2], 0, nullCount);
		301	}
		302	nullLocals[nullCount] = local;
		303	nullReferences[nullCount] = expression;
		304	nullCheckTypes[nullCount++] = status;
		305	}
		306
		307	public void recordUsingNullReference(Scope scope, LocalVariableBinding local,
		308	Expression reference, int checkType, FlowInfo flowInfo) {
		309	if (!flowInfo.isReachable() \|\| flowInfo.isDefinitelyUnknown(local)) {
		310	return;
		311	}
		312	switch (checkType) {
		313	case CAN_ONLY_NULL_NON_NULL :
		314	case CAN_ONLY_NULL:
		315	if (flowInfo.isDefinitelyNonNull(local)) {
		316	if (checkType == CAN_ONLY_NULL_NON_NULL) {
		317	scope.problemReporter().localVariableCannotBeNull(local, reference);
		318	}
		319	return;
181	}	320	}
182	}	321	if (flowInfo.isDefinitelyNull(local)) {
183	nullReferences[nullCount] = expression;	322	scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
184	nullStatus[nullCount++] = status;	323	return;
185	return true;	324	}
186	}	325	if (flowInfo.isPotentiallyUnknown(local)) {
		326	return;
		327	}
		328	recordNullReference(local, reference, checkType);
		329	return;
		330	case MAY_NULL :
		331	if (flowInfo.isDefinitelyNonNull(local)) {
		332	return;
		333	}
		334	if (flowInfo.isDefinitelyNull(local)) {
		335	scope.problemReporter().localVariableCanOnlyBeNull(local, reference);
		336	return;
		337	}
		338	if (flowInfo.isPotentiallyNull(local)) {
		339	scope.problemReporter().localVariableMayBeNull(local, reference);
		340	return;
		341	}
		342	recordNullReference(local, reference, checkType);
		343	return;
		344	default:
		345	// never happens
		346	}
		347	}
187		348
188	void removeFinalAssignmentIfAny(Reference reference) {	349	void removeFinalAssignmentIfAny(Reference reference) {
189	for (int i = 0; i < assignCount; i++) {	350	for (int i = 0; i < assignCount; i++) {