Attachment #183982 for bug #328830

Lines 28-35 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/complete/CompletionOnBranchStatementLabel.java (-2 / +1 lines)
28	this.possibleLabels = possibleLabels;	28	this.possibleLabels = possibleLabels;
29	}	29	}
30		30
31	public FlowInfo analyseCode(BlockScope currentScope,	31	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
32	FlowContext flowContext, FlowInfo flowInfo) {
33	// Is never called	32	// Is never called
34	return null;	33	return null;
35	}	34	}




		super(left, right, operator);
	}

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

		Constant cst = this.left.optimizedBooleanConstant();
		boolean isLeftOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;

			// need to be careful of scenario:
			//  (x && y) && !z, if passing the left info to the right, it would
			// be swapped by the !
			FlowInfo mergedInfo = this.left.analyseCode(currentScope, flowContext, flowInfo, false) // subject to optimization
					.unconditionalInits();
			mergedInfo = this.right.analyseCode(currentScope, flowContext, mergedInfo, valueRequired);
			this.mergedInitStateIndex = currentScope.methodScope()
					.recordInitializationStates(mergedInfo);
			return mergedInfo;
		}

		FlowInfo leftInfo = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
		// need to be careful of scenario:
		//  (x && y) && !z, if passing the left info to the right, it would be
		// swapped by the !

				rightInfo.setReachMode(FlowInfo.UNREACHABLE);
			}
		}
		rightInfo = this.right.analyseCode(currentScope, flowContext, rightInfo, !isLeftOptimizedFalse); // unused if left is false
		if ((this.left.implicitConversion & TypeIds.UNBOXING) != 0) {
			this.left.checkNPE(currentScope, flowContext, flowInfo);
		}

Lines 156-161 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (-1 / +2 lines)
156	// for references on lhs of assignment	156	// for references on lhs of assignment
157	public static final int IsStrictlyAssigned = Bit14; // set only for true assignments, as opposed to compound ones	157	public static final int IsStrictlyAssigned = Bit14; // set only for true assignments, as opposed to compound ones
158	public static final int IsCompoundAssigned = Bit17; // set only for compound assignments, as opposed to other ones	158	public static final int IsCompoundAssigned = Bit17; // set only for compound assignments, as opposed to other ones
		159	public static final int IsInsideCondition = Bit21; // for name/field reference inside a condition
159		160
160	// for explicit constructor call	161	// for explicit constructor call
161	public static final int DiscardEnclosingInstance = Bit14; // used for codegen	162	public static final int DiscardEnclosingInstance = Bit14; // used for codegen
Lines 364-370 Link Here
364	&& field.isOrEnclosedByPrivateType()	365	&& field.isOrEnclosedByPrivateType()
365	&& !scope.isDefinedInField(field)) // ignore cases where field is used from inside itself	366	&& !scope.isDefinedInField(field)) // ignore cases where field is used from inside itself
366	{	367	{
367	if (((filteredBits & IsCompoundAssigned) != 0))	368	if (((filteredBits & (IsCompoundAssigned\|IsInsideCondition)) != 0))
368	// used, but usage may not be relevant	369	// used, but usage may not be relevant
369	field.original().compoundUseFlag++;	370	field.original().compoundUseFlag++;
370	else	371	else

Lines 36-42 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AbstractVariableDeclaration.java (-1 / +1 lines)
36		36
37	public TypeReference type;	37	public TypeReference type;
38		38
39	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	39	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
40	return flowInfo;	40	return flowInfo;
41	}	41	}
42		42




	public Expression[] dimensions;
	public ArrayInitializer initializer;

	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		// allocation itself has no side effect => may optimize all child nodes

		for (int i = 0, max = this.dimensions.length; i < max; i++) {
			Expression dim;
			if ((dim = this.dimensions[i]) != null) {
				flowInfo = dim.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
				if ((dim.implicitConversion & TypeIds.UNBOXING) != 0) {
					dim.checkNPE(currentScope, flowContext, flowInfo);
				}
			}
		}
		if (this.initializer != null) {
			return this.initializer.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
		}
		return flowInfo;
	}




		super();
	}

	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		// initializer itself has no side effect => may optimize all child nodes

		if (this.expressions != null) {
			for (int i = 0, max = this.expressions.length; i < max; i++) {
				flowInfo = this.expressions[i].analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits();
			}
		}
		return flowInfo;




	this.sourceStart = rec.sourceStart;
}

public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean compoundAssignment, boolean valueRequired) {
	// array assignment has a side effect => require values from all child nodes
	
	// TODO (maxime) optimization: unconditionalInits is applied to all existing calls
	if (assignment.expression == null) {
		return analyseCode(currentScope, flowContext, flowInfo, true);
	}
	return assignment
		.expression
		.analyseCode(
			currentScope,
			flowContext,
			analyseCode(currentScope, flowContext, flowInfo, true).unconditionalInits(), true);
}
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	// reference itself has no side effect => may optimize all child nodes
	this.receiver.checkNPE(currentScope, flowContext, flowInfo);
	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
	return this.position.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
}

public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {




	this.sourceEnd = assertExpression.sourceEnd;
}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	// assert may have side effect (throwing) => require values from all child nodes
	this.preAssertInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);

	Constant cst = this.assertExpression.optimizedBooleanConstant();

	boolean isOptimizedFalseAssertion = cst != Constant.NotAConstant && cst.booleanValue() == false;
	
	flowContext.tagBits |= FlowContext.HIDE_NULL_COMPARISON_WARNING;
	FlowInfo conditionFlowInfo = this.assertExpression.analyseCode(currentScope, flowContext, flowInfo.copy(), true);
	flowContext.tagBits &= ~FlowContext.HIDE_NULL_COMPARISON_WARNING;
	UnconditionalFlowInfo assertWhenTrueInfo = conditionFlowInfo.initsWhenTrue().unconditionalInits();
	FlowInfo assertInfo = conditionFlowInfo.initsWhenFalse();


	if (this.exceptionArgument != null) {
		// only gets evaluated when escaping - results are not taken into account
		FlowInfo exceptionInfo = this.exceptionArgument.analyseCode(currentScope, flowContext, assertInfo.copy(), true);

		if (isOptimizedTrueAssertion){
			currentScope.problemReporter().fakeReachable(this.exceptionArgument);

Lines 34-40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java (-2 / +2 lines)
34	this.sourceEnd = sourceEnd;	34	this.sourceEnd = sourceEnd;
35	}	35	}
36		36
37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
38	// record setting a variable: various scenarii are possible, setting an array reference,	38	// record setting a variable: various scenarii are possible, setting an array reference,
39	// a field reference, a blank final field reference, a field of an enclosing instance or	39	// a field reference, a blank final field reference, a field of an enclosing instance or
40	// just a local variable.	40	// just a local variable.
Lines 50-56 Link Here
50	}	50	}
51	}	51	}
52	flowInfo = ((Reference) this.lhs)	52	flowInfo = ((Reference) this.lhs)
53	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)	53	.analyseAssignment(currentScope, flowContext, flowInfo, this, false, valueRequired)
54	.unconditionalInits();	54	.unconditionalInits();
55	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	55	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
56	flowInfo.markNullStatus(local, nullStatus);	56	flowInfo.markNullStatus(local, nullStatus);




	this.sourceStart = expression.sourceStart;
	this.sourceEnd = expression.sourceEnd;
}
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	// keep implementation in sync with CombinedBinaryExpression#analyseCode
	if (this.resolvedType.id == TypeIds.T_JavaLangString) {
		return this.right.analyseCode(
							currentScope, flowContext,
							this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits(), valueRequired)
						.unconditionalInits();
	} else {
		this.left.checkNPE(currentScope, flowContext, flowInfo);
		flowInfo = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits();
		this.right.checkNPE(currentScope, flowContext, flowInfo);
		return this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits();
	}
}





	this.explicitDeclarations = explicitDeclarations;
}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	// empty block
	if (this.statements == null)	return flowInfo;
	int complaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;
	for (int i = 0, max = this.statements.length; i < max; i++) {
		Statement stat = this.statements[i];
		if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {
			flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo, false);
		}
	}
	return flowInfo;

Lines 20-26 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/BreakStatement.java (-1 / +1 lines)
20	super(label, sourceStart, e);	20	super(label, sourceStart, e);
21	}	21	}
22		22
23	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	23	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
24		24
25	// here requires to generate a sequence of finally blocks invocations depending corresponding	25	// here requires to generate a sequence of finally blocks invocations depending corresponding
26	// to each of the traversed try statements, so that execution will terminate properly.	26	// to each of the traversed try statements, so that execution will terminate properly.




	this.sourceStart = sourceStart;
}

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

	if (this.constantExpression != null) {
		if (this.constantExpression.constant == Constant.NotAConstant
				&& !this.constantExpression.resolvedType.isEnum()) {
			currentScope.problemReporter().caseExpressionMustBeConstant(this.constantExpression);
		}
		this.constantExpression.analyseCode(currentScope, flowContext, flowInfo, true); // nothing to optimize here
	}
	return flowInfo;
}

Lines 47-57 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java (-3 / +5 lines)
47	type.bits \|= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage	47	type.bits \|= ASTNode.IgnoreRawTypeCheck; // no need to worry about raw type usage
48	}	48	}
49		49
50	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	50	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		51	boolean isUnboxing = (this.expression.implicitConversion & TypeIds.UNBOXING) != 0;
		52	boolean canThrow = isUnboxing \|\| (this.bits & ASTNode.UnnecessaryCast) == 0;
51	FlowInfo result = this.expression	53	FlowInfo result = this.expression
52	.analyseCode(currentScope, flowContext, flowInfo)	54	.analyseCode(currentScope, flowContext, flowInfo, valueRequired\|\|canThrow) // may optimize if no side effect by throwing (NPE or CCE)
53	.unconditionalInits();	55	.unconditionalInits();
54	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	56	if (isUnboxing) {
55	this.expression.checkNPE(currentScope, flowContext, flowInfo);	57	this.expression.checkNPE(currentScope, flowContext, flowInfo);
56	}	58	}
57	return result;	59	return result;

Lines 30-39 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ClassLiteralAccess.java (-4 / +1 lines)
30	this.sourceEnd = sourceEnd;	30	this.sourceEnd = sourceEnd;
31	}	31	}
32		32
33	public FlowInfo analyseCode(	33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
34	BlockScope currentScope,
35	FlowContext flowContext,
36	FlowInfo flowInfo) {
37		34
38	// if reachable, request the addition of a synthetic field for caching the class descriptor	35	// if reachable, request the addition of a synthetic field for caching the class descriptor
39	SourceTypeBinding sourceType = currentScope.outerMostClassScope().enclosingSourceType();	36	SourceTypeBinding sourceType = currentScope.outerMostClassScope().enclosingSourceType();




}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
		FlowInfo flowInfo, boolean valueRequired) {
	// keep implementation in sync with BinaryExpression#analyseCode
	if (this.referencesTable == null) {
		return super.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
	}
	BinaryExpression cursor;
	if ((cursor = this.referencesTable[0]).resolvedType.id !=
			TypeIds.T_JavaLangString) {
		cursor.left.checkNPE(currentScope, flowContext, flowInfo);
	}
	flowInfo = cursor.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).
		unconditionalInits();
	for (int i = 0, end = this.arity; i < end; i ++) {
		if ((cursor = this.referencesTable[i]).resolvedType.id !=

			cursor.right.checkNPE(currentScope, flowContext, flowInfo);
		}
		flowInfo = cursor.right.
			analyseCode(currentScope, flowContext, flowInfo, valueRequired).
				unconditionalInits();
	}
	if (this.resolvedType.id != TypeIds.T_JavaLangString) {
		this.right.checkNPE(currentScope, flowContext, flowInfo);
	}
	return this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired).
		unconditionalInits();
}





		this.operator = operator ;
	}

	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
			FlowInfo flowInfo, boolean valueRequired) {
		// 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.
		if (this.resolvedType.id != T_JavaLangString) {
			this.lhs.checkNPE(currentScope, flowContext, flowInfo);
		}
		return  ((Reference) this.lhs).analyseAssignment(currentScope, flowContext, flowInfo, this, true, valueRequired).unconditionalInits();
	}
	return  ((Reference) this.lhs).analyseAssignment(currentScope, flowContext, flowInfo, this, true).unconditionalInits();
}

	public boolean checkCastCompatibility() {
		return true;




		this.sourceStart = condition.sourceStart;
		this.sourceEnd = valueIfFalse.sourceEnd;
	}
	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
			FlowInfo flowInfo, boolean valueRequired) {
			FlowInfo flowInfo) {
		int initialComplaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;
		Constant cst = this.condition.optimizedBooleanConstant();
		boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;
		boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;

		int mode = flowInfo.reachMode();
		flowInfo = this.condition.analyseCode(currentScope, flowContext, flowInfo, valueRequired && (cst == Constant.NotAConstant));

		// process the if-true part
		FlowInfo trueFlowInfo = flowInfo.initsWhenTrue().copy();

			}
		}
		this.trueInitStateIndex = currentScope.methodScope().recordInitializationStates(trueFlowInfo);
		trueFlowInfo = this.valueIfTrue.analyseCode(currentScope, flowContext, trueFlowInfo, valueRequired);

		// process the if-false part
		FlowInfo falseFlowInfo = flowInfo.initsWhenFalse().copy();

			}
		}
		this.falseInitStateIndex = currentScope.methodScope().recordInitializationStates(falseFlowInfo);
		falseFlowInfo = this.valueIfFalse.analyseCode(currentScope, flowContext, falseFlowInfo, valueRequired);

		// merge if-true & if-false initializations
		FlowInfo mergedInfo;

Lines 139-145 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java (-2 / +2 lines)
139	}	139	}
140	}	140	}
141	}	141	}
142	flowInfo = this.constructorCall.analyseCode(this.scope, constructorContext, flowInfo);	142	flowInfo = this.constructorCall.analyseCode(this.scope, constructorContext, flowInfo, false); // called as a statement
143	}	143	}
144		144
145	// reuse the reachMode from non static field info	145	// reuse the reachMode from non static field info
Lines 151-157 Link Here
151	for (int i = 0, count = this.statements.length; i < count; i++) {	151	for (int i = 0, count = this.statements.length; i < count; i++) {
152	Statement stat = this.statements[i];	152	Statement stat = this.statements[i];
153	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {	153	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {
154	flowInfo = stat.analyseCode(this.scope, constructorContext, flowInfo);	154	flowInfo = stat.analyseCode(this.scope, constructorContext, flowInfo, false); // ignore any values produced by statements
155	}	155	}
156	}	156	}
157	}	157	}

Lines 20-26 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ContinueStatement.java (-1 / +1 lines)
20	super(label, sourceStart, sourceEnd);	20	super(label, sourceStart, sourceEnd);
21	}	21	}
22		22
23	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	23	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
24		24
25	// here requires to generate a sequence of finally blocks invocations depending corresponding	25	// here requires to generate a sequence of finally blocks invocations depending corresponding
26	// to each of the traversed try statements, so that execution will terminate properly.	26	// to each of the traversed try statements, so that execution will terminate properly.




	if (action instanceof EmptyStatement) action.bits |= ASTNode.IsUsefulEmptyStatement;
}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		
	this.breakLabel = new BranchLabel();
	this.continueLabel = new BranchLabel();
	LoopingFlowContext loopingContext =

	// or catch blocks
	if ((this.action != null) && !this.action.isEmptyBlock()) {
		actionInfo = this.action.
			analyseCode(currentScope, loopingContext, actionInfo, false). // statements, values are ignored
			unconditionalInits();

		// code generation can be optimized when no need to continue in the loop

					null, currentScope)),
			(this.action == null
				? actionInfo
				: (actionInfo.mergedWith(loopingContext.initsOnContinue))).copy(),
			!isConditionOptimizedFalse); // subject to optimization if constant false
	this.preConditionInitStateIndex = currentScope.methodScope().recordInitializationStates(actionInfo);
	if (!isConditionOptimizedFalse && this.continueLabel != null) {
		loopingContext.complainOnDeferredFinalChecks(currentScope, condInfo);

}

public void resolve(BlockScope scope) {
	TypeBinding type = null;
	try {
		scope.isInsideCondition = true;
		type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);
	} finally {
		scope.isInsideCondition = false;
	}
	this.condition.computeConversion(scope, type, type);
	if (this.action != null)
		this.action.resolve(scope);

Lines 24-30 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/EmptyStatement.java (-1 / +1 lines)
24	this.sourceEnd = endPosition;	24	this.sourceEnd = endPosition;
25	}	25	}
26		26
27	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	27	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
28	return flowInfo;	28	return flowInfo;
29	}	29	}
30		30




		// does not preclude the variable from being null in an enclosing scope
	}

	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) 
	{
		FlowInfo result;
		if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
			if ((this.left.constant != Constant.NotAConstant) && (this.left.constant.typeID() == T_boolean)) {
				if (this.left.constant.booleanValue()) { //  true == anything
					//  this is equivalent to the right argument inits
					result = this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
				} else { // false == anything
					//  this is equivalent to the right argument inits negated
					result = this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired).asNegatedCondition();
				}
			}
			else if ((this.right.constant != Constant.NotAConstant) && (this.right.constant.typeID() == T_boolean)) {
				if (this.right.constant.booleanValue()) { //  anything == true
					//  this is equivalent to the left argument inits
					result = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
				} else { // anything == false
					//  this is equivalent to the right argument inits negated
					result = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).asNegatedCondition();
				}
			}
			else {
				result = this.right.analyseCode(
						currentScope, flowContext,
						this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits(),
						valueRequired).
					unconditionalInits();
			}
		} else { //NOT_EQUAL :
			if ((this.left.constant != Constant.NotAConstant) && (this.left.constant.typeID() == T_boolean)) {
				if (!this.left.constant.booleanValue()) { //  false != anything
					//  this is equivalent to the right argument inits
					result = this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
				} else { // true != anything
					//  this is equivalent to the right argument inits negated
					result = this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired).asNegatedCondition();
				}
			}
			else if ((this.right.constant != Constant.NotAConstant) && (this.right.constant.typeID() == T_boolean)) {
				if (!this.right.constant.booleanValue()) { //  anything != false
					//  this is equivalent to the right argument inits
					result = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
				} else { // anything != true
					//  this is equivalent to the right argument inits negated
					result = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).asNegatedCondition();
				}
			}
			else {
				result = this.right.analyseCode(
						currentScope, flowContext,
						this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits(), 
						valueRequired).
					/* unneeded since we flatten it: asNegatedCondition(). */
					unconditionalInits();
			}

Lines 57-63 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ExplicitConstructorCall.java (-3 / +5 lines)
57	this.accessMode = accessMode;	57	this.accessMode = accessMode;
58	}	58	}
59		59
60	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	60	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		61	// called constructor may have side effect => require values from all child nodes
		62
61	// must verify that exceptions potentially thrown by this expression are caught in the method.	63	// must verify that exceptions potentially thrown by this expression are caught in the method.
62		64
63	try {	65	try {
Lines 67-73 Link Here
67	if (this.qualification != null) {	69	if (this.qualification != null) {
68	flowInfo =	70	flowInfo =
69	this.qualification	71	this.qualification
70	.analyseCode(currentScope, flowContext, flowInfo)	72	.analyseCode(currentScope, flowContext, flowInfo, true)
71	.unconditionalInits();	73	.unconditionalInits();
72	}	74	}
73	// process arguments	75	// process arguments
Lines 75-81 Link Here
75	for (int i = 0, max = this.arguments.length; i < max; i++) {	77	for (int i = 0, max = this.arguments.length; i < max; i++) {
76	flowInfo =	78	flowInfo =
77	this.arguments[i]	79	this.arguments[i]
78	.analyseCode(currentScope, flowContext, flowInfo)	80	.analyseCode(currentScope, flowContext, flowInfo, true)
79	.unconditionalInits();	81	.unconditionalInits();
80	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {	82	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
81	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	83	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);




	super();
}

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

/**
 * More sophisticated for of the flow analysis used for analyzing expressions, and be able to optimize out
 * portions of expressions where no actual value is required.

 * @return The state of initialization after the analysis of the current expression
 */
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	return flowInfo;
}

/**

Lines 71-77 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java (-1 / +1 lines)
71	if (this.initialization != null) {	71	if (this.initialization != null) {
72	flowInfo =	72	flowInfo =
73	this.initialization	73	this.initialization
74	.analyseCode(initializationScope, flowContext, flowInfo)	74	.analyseCode(initializationScope, flowContext, flowInfo, true) // side effect => require values
75	.unconditionalInits();	75	.unconditionalInits();
76	flowInfo.markAsDefinitelyAssigned(this.binding);	76	flowInfo.markAsDefinitelyAssigned(this.binding);
77	}	77	}

Lines 59-65 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java (-10 / +13 lines)
59		59
60	}	60	}
61		61
62	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) {	62	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound, boolean valueRequired) {
		63	// generally, the assignment side effect requires all values from child nodes
		64	// - only the receiver of static field access can be optimized out
		65	// assigning to a field doesn't necessarily mark the field as used, only if the value of the assignment itself is used
		66
63	// compound assignment extra work	67	// compound assignment extra work
64	if (isCompound) { // check the variable part is initialized if blank final	68	if (isCompound) { // check the variable part is initialized if blank final
65	if (this.binding.isBlankFinal()	69	if (this.binding.isBlankFinal()
Lines 72-77 Link Here
72	}	76	}
73	}	77	}
74	manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /read-access/);	78	manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /read-access/);
		79	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328830
		80	reportOnlyUselesslyReadPrivateField(currentScope, this.binding, valueRequired);
75	}	81	}
76	flowInfo =	82	flowInfo =
77	this.receiver	83	this.receiver
Lines 81-87 Link Here
81	flowInfo =	87	flowInfo =
82	assignment	88	assignment
83	.expression	89	.expression
84	.analyseCode(currentScope, flowContext, flowInfo)	90	.analyseCode(currentScope, flowContext, flowInfo, true)
85	.unconditionalInits();	91	.unconditionalInits();
86	}	92	}
87	manageSyntheticAccessIfNecessary(currentScope, flowInfo, false /write-access/);	93	manageSyntheticAccessIfNecessary(currentScope, flowInfo, false /write-access/);
Lines 111-122 Link Here
111	return flowInfo;	117	return flowInfo;
112	}	118	}
113		119
114	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
115	return analyseCode(currentScope, flowContext, flowInfo, true);
116	}
117
118	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {	120	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
119	boolean nonStatic = !this.binding.isStatic();	121	boolean nonStatic = !this.binding.isStatic();
		122	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328830
		123	reportOnlyUselesslyReadPrivateField(currentScope, this.binding, valueRequired);
120	this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic);	124	this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic);
121	if (nonStatic) {	125	if (nonStatic) {
122	this.receiver.checkNPE(currentScope, flowContext, flowInfo);	126	this.receiver.checkNPE(currentScope, flowContext, flowInfo);
Lines 291-298 Link Here
291		295
292	public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {	296	public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
293	boolean isStatic;	297	boolean isStatic;
294	// check if compound assignment is the only usage of a private field
295	reportOnlyUselesslyReadPrivateField(currentScope, this.binding, valueRequired);
296	FieldBinding codegenBinding = this.binding.original();	298	FieldBinding codegenBinding = this.binding.original();
297	this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));	299	this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));
298	if (isStatic) {	300	if (isStatic) {
Lines 340-347 Link Here
340		342
341	public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {	343	public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
342	boolean isStatic;	344	boolean isStatic;
343	// check if postIncrement is the only usage of a private field
344	reportOnlyUselesslyReadPrivateField(currentScope, this.binding, valueRequired);
345	FieldBinding codegenBinding = this.binding.original();	345	FieldBinding codegenBinding = this.binding.original();
346	this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));	346	this.receiver.generateCode(currentScope, codeStream, !(isStatic = codegenBinding.isStatic()));
347	if (isStatic) {	347	if (isStatic) {
Lines 523-528 Link Here
523	// constants are propaged when the field is final	523	// constants are propaged when the field is final
524	// and initialized with a (compile time) constant	524	// and initialized with a (compile time) constant
525		525
		526	if (scope.isInsideCondition)
		527	this.bits \|= ASTNode.IsInsideCondition;
		528
526	//always ignore receiver cast, since may affect constant pool reference	529	//always ignore receiver cast, since may affect constant pool reference
527	boolean receiverCast = false;	530	boolean receiverCast = false;
528	if (this.receiver instanceof CastExpression) {	531	if (this.receiver instanceof CastExpression) {




		}
	}

	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		this.breakLabel = new BranchLabel();
		this.continueLabel = new BranchLabel();
		int initialComplaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;

		// process the initializations
		if (this.initializations != null) {
			for (int i = 0, count = this.initializations.length; i < count; i++) {
				flowInfo = this.initializations[i].analyseCode(this.scope, flowContext, flowInfo, false);
			}
		}
		this.preCondInitStateIndex =

						(condLoopContext =
							new LoopingFlowContext(flowContext, flowInfo, this, null,
								null, this.scope)),
						condInfo,
						!isConditionOptimizedFalse);
				if ((this.condition.implicitConversion & TypeIds.UNBOXING) != 0) {
					this.condition.checkNPE(currentScope, flowContext, flowInfo);
				}

					}
				}
			if (this.action.complainIfUnreachable(actionInfo, this.scope, initialComplaintLevel) < Statement.COMPLAINED_UNREACHABLE) {
				actionInfo = this.action.analyseCode(this.scope, loopingContext, actionInfo, false).unconditionalInits();
			}

			// code generation can be optimized when no need to continue in the loop

					currentScope.methodScope().recordInitializationStates(incrementInfo);
				for (int i = 0, count = this.increments.length; i < count; i++) {
					incrementInfo = this.increments[i].
						analyseCode(this.scope, incrementContext, incrementInfo, false);
				}
				incrementContext.complainOnDeferredFinalChecks(this.scope,
						actionInfo = incrementInfo.unconditionalInits());

			for (int i = 0, length = this.initializations.length; i < length; i++)
				this.initializations[i].resolve(this.scope);
		if (this.condition != null) {
			TypeBinding type = null;
			try {
				upperScope.isInsideCondition = true;
				type = this.condition.resolveTypeExpecting(this.scope, TypeBinding.BOOLEAN);
			} finally  {
				upperScope.isInsideCondition = false;
			}
			this.condition.computeConversion(this.scope, type, type);
		}
		if (this.increments != null)




		this.kind = -1;
	}

	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		// initialize break and continue labels
		this.breakLabel = new BranchLabel();
		this.continueLabel = new BranchLabel();


		// process the element variable and collection
		this.collection.checkNPE(currentScope, flowContext, flowInfo);
		flowInfo = this.elementVariable.analyseCode(this.scope, flowContext, flowInfo, false); // analyse as a statement -> ignore value		
		FlowInfo condInfo = this.collection.analyseCode(this.scope, flowContext, flowInfo.copy(), true); // collection value is required

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

				&& currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3))) {

			if (this.action.complainIfUnreachable(actionInfo, this.scope, initialComplaintLevel) < Statement.COMPLAINED_UNREACHABLE) {
				actionInfo = this.action.analyseCode(this.scope, loopingContext, actionInfo, false).unconditionalCopy(); // statement values are ignored
			}

			// code generation can be optimized when no need to continue in the loop




	this.sourceEnd = sourceEnd;
}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	// process the condition
	Constant cst = this.condition.optimizedBooleanConstant();
	
	boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;
	boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;
	boolean hasThenPart = this.thenStatement != null && !this.thenStatement.isEmptyBlock();
	boolean hasElsePart = this.elseStatement != null && !this.elseStatement.isEmptyBlock();

	boolean conditionValueRequired = true;
	if (hasThenPart) {
		// will generate boolean condition only if needed
		if (isConditionOptimizedTrue)
			conditionValueRequired = false;
	} else if (hasElsePart) {
		// will generate boolean condition only if needed
		if (isConditionOptimizedFalse)
			conditionValueRequired = false;
	} else {
		conditionValueRequired = false;
	}

	FlowInfo conditionFlowInfo = this.condition.analyseCode(currentScope, flowContext, flowInfo, conditionValueRequired);
	int initialComplaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;

	Constant cst = this.condition.optimizedBooleanConstant();
	if ((this.condition.implicitConversion & TypeIds.UNBOXING) != 0) {
		this.condition.checkNPE(currentScope, flowContext, flowInfo);
	}



	// process the THEN part
	FlowInfo thenFlowInfo = conditionFlowInfo.safeInitsWhenTrue();

		// No need if the whole if-else construct itself lies in unreachable code
		this.bits |= ASTNode.IsElseStatementUnreachable;
	}
	
	if (this.thenStatement != null) {
		// Save info for code gen
		this.thenInitStateIndex = currentScope.methodScope().recordInitializationStates(thenFlowInfo);

				this.bits &= ~ASTNode.IsThenStatementUnreachable;
			}
		}
		thenFlowInfo = this.thenStatement.analyseCode(currentScope, flowContext, thenFlowInfo, false); // analyse as statement, ignore value
	}
	// code gen: optimizing the jump around the ELSE part
	if ((thenFlowInfo.tagBits & FlowInfo.UNREACHABLE) != 0) {

				this.bits &= ~ASTNode.IsElseStatementUnreachable;
			}
		}
		elseFlowInfo = this.elseStatement.analyseCode(currentScope, flowContext, elseFlowInfo, false); // analyse as statement, ignore value
	}
	// merge THEN & ELSE initializations
	FlowInfo mergedInfo = FlowInfo.mergedOptimizedBranchesIfElse(

}

public void resolve(BlockScope scope) {
	TypeBinding type = null;
	try {
		scope.isInsideCondition = true;
		type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);
	} finally {
		scope.isInsideCondition = false;
	}
	this.condition.computeConversion(scope, type, type);
	if (this.thenStatement != null)
		this.thenStatement.resolve(scope);




		}
	}

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

		if (this.block != null) {
			return this.block.analyseCode(currentScope, flowContext, flowInfo, false); // statements, ignore value
		}
		return flowInfo;
	}




	this.sourceEnd = type.sourceEnd;
}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	LocalVariableBinding local = this.expression.localVariableBinding();
	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
		flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo, valueRequired).
			unconditionalInits();
		FlowInfo initsWhenTrue = flowInfo.copy();
		initsWhenTrue.markAsComparedEqualToNonNull(local);

		// no impact upon enclosing try context
		return FlowInfo.conditional(initsWhenTrue, flowInfo.copy());
	}
	return this.expression.analyseCode(currentScope, flowContext, flowInfo, valueRequired).
			unconditionalInits();
}





		this.sourceEnd = sourceEnd;
	}

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

		// need to stack a context to store explicit label, answer inits in case of normal completion merged
		// with those relative to the exit path from break statement occurring inside the labeled statement.

						this.label,
						(this.targetLabel = new BranchLabel()),
						currentScope)),
				flowInfo,
				false);	// statement, value ignored
			boolean reinjectNullInfo = (statementInfo.tagBits & FlowInfo.UNREACHABLE) != 0 &&
				(labelContext.initsOnBreak.tagBits & FlowInfo.UNREACHABLE) == 0;
			mergedInfo = statementInfo.mergedWith(labelContext.initsOnBreak);




 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;

import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.*;
import org.eclipse.jdt.internal.compiler.lookup.*;


		this.sourceEnd = e;
	}

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

		return flowInfo;
	}

	public abstract void computeConstant();

	public abstract TypeBinding literalType(BlockScope scope);




		this.declarationEnd = sourceEnd;
	}

	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		// record variable initialization if any
		if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
			this.bits |= ASTNode.IsLocalDeclarationReachable; // only set if actually reached
		}
		if (this.initialization == null) {
			return flowInfo;
		}
		if ((this.initialization.implicitConversion & TypeIds.UNBOXING) != 0) {
			this.initialization.checkNPE(currentScope, flowContext, flowInfo);
		}
		int nullStatus = this.initialization.nullStatus(flowInfo);
		flowInfo =
			this.initialization
				.analyseCode(currentScope, flowContext, flowInfo, true) // at this point we must assume that the local is used, thus the side effect requires the value
				.unconditionalInits();
		if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes
			this.bits |= FirstAssignmentToLocal;
		} else {
			this.bits &= ~FirstAssignmentToLocal;  // int i = (i = 0);
		}
		flowInfo.markAsDefinitelyAssigned(this.binding);
		if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {
			flowInfo.markNullStatus(this.binding, nullStatus);
			// no need to inform enclosing try block since its locals won't get
			// known by the finally block
		}
		return flowInfo;
	}
	if ((this.initialization.implicitConversion & TypeIds.UNBOXING) != 0) {
		this.initialization.checkNPE(currentScope, flowContext, flowInfo);
	}
	int nullStatus = this.initialization.nullStatus(flowInfo);
	flowInfo =
		this.initialization
			.analyseCode(currentScope, flowContext, flowInfo)
			.unconditionalInits();
	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes
		this.bits |= FirstAssignmentToLocal;
	} else {
		this.bits &= ~FirstAssignmentToLocal;  // int i = (i = 0);
	}
	flowInfo.markAsDefinitelyAssigned(this.binding);
	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {
		flowInfo.markNullStatus(this.binding, nullStatus);
		// no need to inform enclosing try block since its locals won't get
		// known by the finally block
	}
	return flowInfo;
}

	public void checkModifiers() {


Lines 56-62 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-2 / +4 lines)
56	public TypeReference[] typeArguments;	56	public TypeReference[] typeArguments;
57	public TypeBinding[] genericTypeArguments;	57	public TypeBinding[] genericTypeArguments;
58		58
59	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	59	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		60	// method execution may have side effect => require values from all child nodes
		61	// - exception: receiver of call to static method
60	boolean nonStatic = !this.binding.isStatic();	62	boolean nonStatic = !this.binding.isStatic();
61	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();	63	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, nonStatic).unconditionalInits();
62	if (nonStatic) {	64	if (nonStatic) {
Lines 69-75 Link Here
69	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {	71	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
70	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	72	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
71	}	73	}
72	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	74	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo, true).unconditionalInits();
73	}	75	}
74	}	76	}
75	ReferenceBinding[] thrownExceptions;	77	ReferenceBinding[] thrownExceptions;

Lines 86-92 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java (-1 / +1 lines)
86	for (int i = 0, count = this.statements.length; i < count; i++) {	86	for (int i = 0, count = this.statements.length; i < count; i++) {
87	Statement stat = this.statements[i];	87	Statement stat = this.statements[i];
88	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {	88	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {
89	flowInfo = stat.analyseCode(this.scope, methodContext, flowInfo);	89	flowInfo = stat.analyseCode(this.scope, methodContext, flowInfo, false);
90	}	90	}
91	}	91	}
92	}	92	}




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

		Constant cst = this.left.optimizedBooleanConstant();
		boolean isLeftOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;

			// FALSE || anything
			 // need to be careful of scenario:
			//		(x || y) || !z, if passing the left info to the right, it would be swapped by the !
			FlowInfo mergedInfo = this.left.analyseCode(currentScope, flowContext, flowInfo, false).unconditionalInits(); // subject to optimization
			mergedInfo = this.right.analyseCode(currentScope, flowContext, mergedInfo, valueRequired);
			this.mergedInitStateIndex =
				currentScope.methodScope().recordInitializationStates(mergedInfo);
			return mergedInfo;
		}

		FlowInfo leftInfo = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired);

		 // need to be careful of scenario:
		//		(x || y) || !z, if passing the left info to the right, it would be swapped by the !

				rightInfo.setReachMode(FlowInfo.UNREACHABLE);
			}
		}
		rightInfo = this.right.analyseCode(currentScope, flowContext, rightInfo, !isLeftOptimizedTrue); // unused if left is true
		if ((this.left.implicitConversion & TypeIds.UNBOXING) != 0) {
			this.left.checkNPE(currentScope, flowContext, flowInfo);
		}

Lines 60-66 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-9 / +14 lines)
60	this.sourceEnd = sourceEnd;	60	this.sourceEnd = sourceEnd;
61	}	61	}
62		62
63	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) {	63	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound, boolean valueRequired) {
64	// determine the rank until which we now we do not need any actual value for the field access	64	// determine the rank until which we now we do not need any actual value for the field access
65	int otherBindingsCount = this.otherBindings == null ? 0 : this.otherBindings.length;	65	int otherBindingsCount = this.otherBindings == null ? 0 : this.otherBindings.length;
66	boolean needValue = otherBindingsCount == 0 \|\| !this.otherBindings[0].isStatic();	66	boolean needValue = otherBindingsCount == 0 \|\| !this.otherBindings[0].isStatic();
Lines 116-121 Link Here
116	}	116	}
117		117
118	if (isCompound) {	118	if (isCompound) {
		119	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328830
		120	reportOnlyUselesslyReadPrivateField(currentScope, lastFieldBinding, valueRequired);
119	if (otherBindingsCount == 0	121	if (otherBindingsCount == 0
120	&& lastFieldBinding.isBlankFinal()	122	&& lastFieldBinding.isBlankFinal()
121	&& currentScope.needBlankFinalFieldInitializationCheck(lastFieldBinding)) {	123	&& currentScope.needBlankFinalFieldInitializationCheck(lastFieldBinding)) {
Lines 131-137 Link Here
131	flowInfo =	133	flowInfo =
132	assignment	134	assignment
133	.expression	135	.expression
134	.analyseCode(currentScope, flowContext, flowInfo)	136	.analyseCode(currentScope, flowContext, flowInfo, true) // assignment side effect => require value
135	.unconditionalInits();	137	.unconditionalInits();
136	}	138	}
137		139
Lines 161-176 Link Here
161	return flowInfo;	163	return flowInfo;
162	}	164	}
163		165
164	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
165	return analyseCode(currentScope, flowContext, flowInfo, true);
166	}
167
168	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {	166	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
169	// determine the rank until which we now we do not need any actual value for the field access	167	// determine the rank until which we now we do not need any actual value for the field access
170	int otherBindingsCount = this.otherBindings == null ? 0 : this.otherBindings.length;	168	int otherBindingsCount = this.otherBindings == null ? 0 : this.otherBindings.length;
171		169
172	boolean needValue = otherBindingsCount == 0 ? valueRequired : !this.otherBindings[0].isStatic();	170	boolean needValue = otherBindingsCount == 0 ? valueRequired : !this.otherBindings[0].isStatic();
173	boolean complyTo14 = currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4;	171	boolean complyTo14 = currentScope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_4;
		172	FieldBinding lastFieldBinding = null;
174	switch (this.bits & ASTNode.RestrictiveFlagMASK) {	173	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
175	case Binding.FIELD : // reading a field	174	case Binding.FIELD : // reading a field
176	if (needValue \|\| complyTo14) {	175	if (needValue \|\| complyTo14) {
Lines 186-191 Link Here
186	currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);	185	currentScope.problemReporter().uninitializedBlankFinalField(fieldBinding, this);
187	}	186	}
188	}	187	}
		188	lastFieldBinding = fieldBinding;
189	}	189	}
190	break;	190	break;
191	case Binding.LOCAL : // reading a local variable	191	case Binding.LOCAL : // reading a local variable
Lines 213-219 Link Here
213	manageSyntheticAccessIfNecessary(currentScope, this.otherBindings[i], i + 1, flowInfo);	213	manageSyntheticAccessIfNecessary(currentScope, this.otherBindings[i], i + 1, flowInfo);
214	}	214	}
215	}	215	}
		216	lastFieldBinding = this.otherBindings[otherBindingsCount-1];
216	}	217	}
		218	if (lastFieldBinding != null)
		219	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328830
		220	reportOnlyUselesslyReadPrivateField(currentScope, lastFieldBinding, valueRequired);
217	return flowInfo;	221	return flowInfo;
218	}	222	}
219		223
Lines 382-388 Link Here
382	public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {	386	public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
383	FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);	387	FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);
384	// check if compound assignment is the only usage of a private field	388	// check if compound assignment is the only usage of a private field
385	reportOnlyUselesslyReadPrivateField(currentScope, lastFieldBinding, valueRequired);
386	boolean isFirst = lastFieldBinding == this.binding	389	boolean isFirst = lastFieldBinding == this.binding
387	&& (this.indexOfFirstFieldBinding == 1 \|\| lastFieldBinding.declaringClass == currentScope.enclosingReceiverType())	390	&& (this.indexOfFirstFieldBinding == 1 \|\| lastFieldBinding.declaringClass == currentScope.enclosingReceiverType())
388	&& this.otherBindings == null; // could be dup: next.next.next	391	&& this.otherBindings == null; // could be dup: next.next.next
Lines 434-441 Link Here
434		437
435	public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {	438	public void generatePostIncrement(BlockScope currentScope, CodeStream codeStream, CompoundAssignment postIncrement, boolean valueRequired) {
436	FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);	439	FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);
437	// check if this post increment is the only usage of a private field
438	reportOnlyUselesslyReadPrivateField(currentScope, lastFieldBinding, valueRequired);
439	boolean isFirst = lastFieldBinding == this.binding	440	boolean isFirst = lastFieldBinding == this.binding
440	&& (this.indexOfFirstFieldBinding == 1 \|\| lastFieldBinding.declaringClass == currentScope.enclosingReceiverType())	441	&& (this.indexOfFirstFieldBinding == 1 \|\| lastFieldBinding.declaringClass == currentScope.enclosingReceiverType())
441	&& this.otherBindings == null; // could be dup: next.next.next	442	&& this.otherBindings == null; // could be dup: next.next.next
Lines 919-924 Link Here
919	// field and/or local are done before type lookups	920	// field and/or local are done before type lookups
920	// the only available value for the restrictiveFlag BEFORE	921	// the only available value for the restrictiveFlag BEFORE
921	// the TC is Flag_Type Flag_LocalField and Flag_TypeLocalField	922	// the TC is Flag_Type Flag_LocalField and Flag_TypeLocalField
		923
		924	if (scope.isInsideCondition)
		925	this.bits \|= ASTNode.IsInsideCondition;
		926
922	this.actualReceiverType = scope.enclosingReceiverType();	927	this.actualReceiverType = scope.enclosingReceiverType();
923	this.constant = Constant.NotAConstant;	928	this.constant = Constant.NotAConstant;
924	if ((this.binding = scope.getBinding(this.tokens, this.bits & ASTNode.RestrictiveFlagMASK, this, true /resolve/)).isValidBinding()) {	929	if ((this.binding = scope.getBinding(this.tokens, this.bits & ASTNode.RestrictiveFlagMASK, this, true /resolve/)).isValidBinding()) {




package org.eclipse.jdt.internal.compiler.ast;

import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;

public class QualifiedThisReference extends ThisReference {


		this.sourceStart = name.sourceStart;
	}

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

		return flowInfo;
	}

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

		return flowInfo;
	}

	/**
	 * Code generation for QualifiedThisReference
	 *




import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

public Reference() {
	super();
}
public abstract FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound, boolean valueRequired);

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

public FieldBinding fieldBinding() {
	//this method should be sent one FIELD-tagged references

		}
	}
}
/* report a local/arg that is only read from a 'special operator',
 * i.e., in a postIncrement expression or a compound assignment,
 * where the information is never flowing out off the local/arg. */
static void reportOnlyUselesslyReadLocal(BlockScope currentScope, LocalVariableBinding localBinding, boolean valueRequired) {
	if (localBinding.declaration == null)
		return;  // secret local
	if ((localBinding.declaration.bits & ASTNode.IsLocalDeclarationReachable) == 0)
		return;  // declaration is unreachable
	if (localBinding.useFlag >= LocalVariableBinding.USED)
		return;  // we're only interested in cases with only compound access (negative count)

	if (valueRequired) {
		// access is relevant
		localBinding.useFlag = LocalVariableBinding.USED;
		return;
	} else {
		localBinding.useFlag++;
		if (localBinding.useFlag != LocalVariableBinding.UNUSED) // have all negative counts been consumed?
			return; // still waiting to see more usages of this kind
	}
	// at this point we know we have something to report
	if (localBinding.declaration instanceof Argument) {
		// check compiler options to report against unused arguments
		MethodScope methodScope = currentScope.methodScope();
		if (methodScope != null) {
			MethodBinding method = ((AbstractMethodDeclaration)methodScope.referenceContext()).binding;
			
			boolean shouldReport = !method.isMain();
			if (method.isImplementing()) {
				shouldReport &= currentScope.compilerOptions().reportUnusedParameterWhenImplementingAbstract;
			} else if (method.isOverriding()) {
				shouldReport &= currentScope.compilerOptions().reportUnusedParameterWhenOverridingConcrete;
			}
			
			if (shouldReport) {
				// report the case of an argument that is unread except through a special operator
				currentScope.problemReporter().unusedArgument(localBinding.declaration);
			}
		}
	} else {
		// report the case of a local variable that is unread except for a special operator
		currentScope.problemReporter().unusedLocalVariable(localBinding.declaration);
	}
	localBinding.useFlag = LocalVariableBinding.USED; // don't report again
}
}




	this.expression = expression ;
}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {	// here requires to generate a sequence of finally blocks invocations depending corresponding
	// to each of the traversed try statements, so that execution will terminate properly.

	// lookup the label, this should answer the returnContext

	if (this.expression != null) {
		flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo, true);
		if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
			this.expression.checkNPE(currentScope, flowContext, flowInfo);
		}

Lines 57-63 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java (-38 / +34 lines)
57	this.sourceEnd = (int) pos;	57	this.sourceEnd = (int) pos;
58	}	58	}
59		59
60	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) {	60	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound, boolean valueRequired) {
61	boolean isReachable = (flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0;	61	boolean isReachable = (flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0;
62	// compound assignment extra work	62	// compound assignment extra work
63	if (isCompound) { // check the variable part is initialized if blank final	63	if (isCompound) { // check the variable part is initialized if blank final
Lines 72-77 Link Here
72	}	72	}
73	}	73	}
74	manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /read-access/);	74	manageSyntheticAccessIfNecessary(currentScope, flowInfo, true /read-access/);
		75	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328830
		76	reportOnlyUselesslyReadPrivateField(currentScope, fieldBinding, valueRequired);
75	break;	77	break;
76	case Binding.LOCAL : // reading a local variable	78	case Binding.LOCAL : // reading a local variable
77	// check if assigning a final blank field	79	// check if assigning a final blank field
Lines 80-100 Link Here
80	currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);	82	currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
81	// we could improve error msg here telling "cannot use compound assignment on final local variable"	83	// we could improve error msg here telling "cannot use compound assignment on final local variable"
82	}	84	}
83	if (localBinding.useFlag != LocalVariableBinding.USED) {	85	if (isReachable) {
84	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=185682	86	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=185682
85	// access from compound assignment does not prevent "unused" warning, unless unboxing is involved:	87	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328830
86	if (isReachable && (this.implicitConversion & TypeIds.UNBOXING) != 0) {	88	// access from compound assignment does not prevent "unused" warning / optimization
		89	if ((this.implicitConversion & TypeIds.UNBOXING) != 0 // cannot optimize if unboxing is involved
		90	\|\| valueRequired) // cannot optimize if value is required
		91	{
87	localBinding.useFlag = LocalVariableBinding.USED;	92	localBinding.useFlag = LocalVariableBinding.USED;
88	} else {
89	// use values < 0 to count the number of compound uses:
90	if (localBinding.useFlag <= LocalVariableBinding.UNUSED)
91	localBinding.useFlag--;
92	}	93	}
		94	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
		95	localBinding.useFlag = LocalVariableBinding.FAKE_USED;
93	}	96	}
94	}	97	}
95	}	98	}
96	if (assignment.expression != null) {	99	if (assignment.expression != null) {
97	flowInfo = assignment.expression.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	100	flowInfo = assignment.expression.analyseCode(currentScope, flowContext, flowInfo, true).unconditionalInits();
98	}	101	}
99	switch (this.bits & ASTNode.RestrictiveFlagMASK) {	102	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
100	case Binding.FIELD : // assigning to a field	103	case Binding.FIELD : // assigning to a field
Lines 146-155 Link Here
146	return flowInfo;	149	return flowInfo;
147	}	150	}
148		151
149	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
150	return analyseCode(currentScope, flowContext, flowInfo, true);
151	}
152
153	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {	152	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
154	switch (this.bits & ASTNode.RestrictiveFlagMASK) {	153	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
155	case Binding.FIELD : // reading a field	154	case Binding.FIELD : // reading a field
Lines 158-163 Link Here
158	}	157	}
159	// check if reading a final blank field	158	// check if reading a final blank field
160	FieldBinding fieldBinding = (FieldBinding) this.binding;	159	FieldBinding fieldBinding = (FieldBinding) this.binding;
		160	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=328830
		161	reportOnlyUselesslyReadPrivateField(currentScope, fieldBinding.original(), valueRequired);
161	if (fieldBinding.isBlankFinal() && currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) {	162	if (fieldBinding.isBlankFinal() && currentScope.needBlankFinalFieldInitializationCheck(fieldBinding)) {
162	FlowInfo fieldInits = flowContext.getInitsForFinalBlankInitializationCheck(fieldBinding.declaringClass.original(), flowInfo);	163	FlowInfo fieldInits = flowContext.getInitsForFinalBlankInitializationCheck(fieldBinding.declaringClass.original(), flowInfo);
163	if (!fieldInits.isDefinitelyAssigned(fieldBinding)) {	164	if (!fieldInits.isDefinitelyAssigned(fieldBinding)) {
Lines 171-177 Link Here
171	currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);	172	currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
172	}	173	}
173	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {	174	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
174	localBinding.useFlag = LocalVariableBinding.USED;	175	// check possibility for optimization (https://bugs.eclipse.org/328830):
		176	if ((this.implicitConversion & TypeIds.UNBOXING) != 0 // cannot optimize if unboxing is involved
		177	\|\| valueRequired) // cannot optimize if value is required
		178	{
		179	localBinding.useFlag = LocalVariableBinding.USED;
		180	}
175	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {	181	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
176	localBinding.useFlag = LocalVariableBinding.FAKE_USED;	182	localBinding.useFlag = LocalVariableBinding.FAKE_USED;
177	}	183	}
Lines 427-433 Link Here
427	if (valueRequired) {	433	if (valueRequired) {
428	// restart code gen	434	// restart code gen
429	localBinding.useFlag = LocalVariableBinding.USED;	435	localBinding.useFlag = LocalVariableBinding.USED;
430	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);	436	//throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);
		437	currentScope.problemReporter().abortDueToInternalError("Unexpected unresolved local");
431	}	438	}
432	codeStream.recordPositionsFrom(pc, this.sourceStart);	439	codeStream.recordPositionsFrom(pc, this.sourceStart);
433	return;	440	return;
Lines 479-495 Link Here
479	* are optimized in one access: e.g "a = a + 1" optimized into "a++".	486	* are optimized in one access: e.g "a = a + 1" optimized into "a++".
480	*/	487	*/
481	public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {	488	public void generateCompoundAssignment(BlockScope currentScope, CodeStream codeStream, Expression expression, int operator, int assignmentImplicitConversion, boolean valueRequired) {
482	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=185682
483	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
484	case Binding.LOCAL:
485	LocalVariableBinding localBinding = (LocalVariableBinding) this.binding;
486	// check if compound assignment is the only usage of this local
487	Reference.reportOnlyUselesslyReadLocal(currentScope, localBinding, valueRequired);
488	break;
489	case Binding.FIELD:
490	// check if compound assignment is the only usage of a private field
491	reportOnlyUselesslyReadPrivateField(currentScope, (FieldBinding)this.binding, valueRequired);
492	}
493	this.generateCompoundAssignment(	489	this.generateCompoundAssignment(
494	currentScope,	490	currentScope,
495	codeStream,	491	codeStream,
Lines 538-548 Link Here
538	Constant assignConstant;	534	Constant assignConstant;
539	switch (localBinding.type.id) {	535	switch (localBinding.type.id) {
540	case T_JavaLangString :	536	case T_JavaLangString :
541	codeStream.generateStringConcatenationAppend(currentScope, this, expression);	537	if (valueRequired \|\| localBinding.useFlag > LocalVariableBinding.UNUSED) {
542	if (valueRequired) {	538	codeStream.generateStringConcatenationAppend(currentScope, this, expression);
543	codeStream.dup();	539	if (valueRequired) {
		540	codeStream.dup();
		541	}
		542	codeStream.store(localBinding, false);
544	}	543	}
545	codeStream.store(localBinding, false);
546	return;	544	return;
547	case T_int :	545	case T_int :
548	assignConstant = expression.constant;	546	assignConstant = expression.constant;
Lines 554-560 Link Here
554	* - the constant can have potential side-effect	552	* - the constant can have potential side-effect
555	*/	553	*/
556	localBinding.useFlag = LocalVariableBinding.USED;	554	localBinding.useFlag = LocalVariableBinding.USED;
557	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);	555	// throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);
		556	currentScope.problemReporter().abortDueToInternalError("Unexpected unresolved local");
558	} else if (assignConstant == Constant.NotAConstant) {	557	} else if (assignConstant == Constant.NotAConstant) {
559	// we only need to generate the value of the expression's constant if it is not a constant expression	558	// we only need to generate the value of the expression's constant if it is not a constant expression
560	expression.generateCode(currentScope, codeStream, false);	559	expression.generateCode(currentScope, codeStream, false);
Lines 660-668 Link Here
660	switch (this.bits & ASTNode.RestrictiveFlagMASK) {	659	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
661	case Binding.FIELD : // assigning to a field	660	case Binding.FIELD : // assigning to a field
662	FieldBinding fieldBinding = (FieldBinding)this.binding;	661	FieldBinding fieldBinding = (FieldBinding)this.binding;
663	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=185682
664	// check if postIncrement is the only usage of a private field
665	reportOnlyUselesslyReadPrivateField(currentScope, fieldBinding, valueRequired);
666	FieldBinding codegenField = fieldBinding.original();	662	FieldBinding codegenField = fieldBinding.original();
667	if (codegenField.isStatic()) {	663	if (codegenField.isStatic()) {
668	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	664	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
Lines 726-739 Link Here
726	return;	722	return;
727	case Binding.LOCAL : // assigning to a local variable	723	case Binding.LOCAL : // assigning to a local variable
728	LocalVariableBinding localBinding = (LocalVariableBinding) this.binding;	724	LocalVariableBinding localBinding = (LocalVariableBinding) this.binding;
729	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=185682
730	// check if postIncrement is the only usage of this local
731	Reference.reportOnlyUselesslyReadLocal(currentScope, localBinding, valueRequired);
732	if (localBinding.resolvedPosition == -1) {	725	if (localBinding.resolvedPosition == -1) {
733	if (valueRequired) {	726	if (valueRequired) {
734	// restart code gen	727	// restart code gen
735	localBinding.useFlag = LocalVariableBinding.USED;	728	localBinding.useFlag = LocalVariableBinding.USED;
736	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);	729	// throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);
		730	currentScope.problemReporter().abortDueToInternalError("Unexpected unresolved local");
737	}	731	}
738	return;	732	return;
739	}	733	}
Lines 914-919 Link Here
914	}	908	}
915		909
916	public TypeBinding resolveType(BlockScope scope) {	910	public TypeBinding resolveType(BlockScope scope) {
		911	if (scope.isInsideCondition)
		912	this.bits \|= ASTNode.IsInsideCondition;
917	// for code gen, harm the restrictiveFlag	913	// for code gen, harm the restrictiveFlag
918		914
919	if (this.actualReceiverType != null) {	915	if (this.actualReceiverType != null) {

Lines 48-54 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Statement.java (-1 / +1 lines)
48	// }	48	// }
49	return false;	49	return false;
50	}	50	}
51	public abstract FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo);	51	public abstract FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired);
52		52
53	public static final int NOT_COMPLAINED = 0;	53	public static final int NOT_COMPLAINED = 0;
54	public static final int COMPLAINED_FAKE_REACHABLE = 1;	54	public static final int COMPLAINED_FAKE_REACHABLE = 1;

Lines 45-53 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java (-5 / +16 lines)
45	int preSwitchInitStateIndex = -1;	45	int preSwitchInitStateIndex = -1;
46	int mergedInitStateIndex = -1;	46	int mergedInitStateIndex = -1;
47		47
48	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	48	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
49	try {	49	try {
50	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo);	50	boolean expressionValueRequired = this.caseCount != 0 \|\| // case-less: subject to optimization
		51	((this.expression.constant == Constant.NotAConstant) // constant branching ...
		52	&& (this.expression.implicitConversion & TypeIds.UNBOXING) != 0); // ... which cannot throw NPE?
		53	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo, expressionValueRequired);
51	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	54	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
52	this.expression.checkNPE(currentScope, flowContext, flowInfo);	55	this.expression.checkNPE(currentScope, flowContext, flowInfo);
53	}	56	}
Lines 89-95 Link Here
89	fallThroughState = FALLTHROUGH; // reset below if needed	92	fallThroughState = FALLTHROUGH; // reset below if needed
90	}	93	}
91	if ((complaintLevel = statement.complainIfUnreachable(caseInits, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {	94	if ((complaintLevel = statement.complainIfUnreachable(caseInits, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {
92	caseInits = statement.analyseCode(this.scope, switchContext, caseInits);	95	caseInits = statement.analyseCode(this.scope, switchContext, caseInits, false); // analyse as statement => ignore value
93	if (caseInits == FlowInfo.DEAD_END) {	96	if (caseInits == FlowInfo.DEAD_END) {
94	fallThroughState = ESCAPING;	97	fallThroughState = ESCAPING;
95	}	98	}
Lines 162-168 Link Here
162	codeStream.pop();	165	codeStream.pop();
163	}	166	}
164	} else {	167	} else {
165	valueRequired = this.expression.constant == Constant.NotAConstant \|\| hasCases;	168	valueRequired = hasCases \|\|
		169	((this.expression.constant == Constant.NotAConstant)
		170	&& (this.expression.implicitConversion & TypeIds.UNBOXING) != 0);
166	// generate expression	171	// generate expression
167	this.expression.generateCode(currentScope, codeStream, valueRequired);	172	this.expression.generateCode(currentScope, codeStream, valueRequired);
168	}	173	}
Lines 267-273 Link Here
267	public void resolve(BlockScope upperScope) {	272	public void resolve(BlockScope upperScope) {
268	try {	273	try {
269	boolean isEnumSwitch = false;	274	boolean isEnumSwitch = false;
270	TypeBinding expressionType = this.expression.resolveType(upperScope);	275	TypeBinding expressionType = null;
		276	try {
		277	upperScope.isInsideCondition = true;
		278	expressionType = this.expression.resolveType(upperScope);
		279	} finally {
		280	upperScope.isInsideCondition = false;
		281	}
271	if (expressionType != null) {	282	if (expressionType != null) {
272	this.expression.computeConversion(upperScope, expressionType, expressionType);	283	this.expression.computeConversion(upperScope, expressionType, expressionType);
273	checkType: {	284	checkType: {




	this.sourceEnd = e;
	this.sourceStart = s;
}
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
public FlowInfo analyseCode(
	BlockScope currentScope,
	FlowContext flowContext,
	FlowInfo flowInfo) {

	this.preSynchronizedInitStateIndex =
		currentScope.methodScope().recordInitializationStates(flowInfo);

		this.block.analyseCode(
			this.scope,
			new InsideSubRoutineFlowContext(flowContext, this),
			this.expression.analyseCode(this.scope, flowContext, flowInfo, true), // require expression value 
			false); 															  // ignore value of statements

	this.mergedSynchronizedInitStateIndex =
		currentScope.methodScope().recordInitializationStates(flowInfo);

Lines 35-41 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ThisReference.java (-1 / +1 lines)
35	/*	35	/*
36	* @see Reference#analyseAssignment(...)	36	* @see Reference#analyseAssignment(...)
37	*/	37	*/
38	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound) {	38	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean isCompound, boolean valueRequired) {
39		39
40	return flowInfo; // this cannot be assigned	40	return flowInfo; // this cannot be assigned
41	}	41	}

Lines 30-37 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ThrowStatement.java (-2 / +2 lines)
30	this.sourceEnd = sourceEnd;	30	this.sourceEnd = sourceEnd;
31	}	31	}
32		32
33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
34	this.exception.analyseCode(currentScope, flowContext, flowInfo);	34	this.exception.analyseCode(currentScope, flowContext, flowInfo, true); // cannot optimize
35	this.exception.checkNPE(currentScope, flowContext, flowInfo);	35	this.exception.checkNPE(currentScope, flowContext, flowInfo);
36	// need to check that exception thrown is actually caught somewhere	36	// need to check that exception thrown is actually caught somewhere
37	flowContext.checkExceptionHandlers(this.exceptionType, this, flowInfo, currentScope);	37	flowContext.checkExceptionHandlers(this.exceptionType, this, flowInfo, currentScope);




	int naturalExitMergeInitStateIndex = -1;
	int[] catchExitInitStateIndexes;

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

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
	// 
	
	// Consider the try block and catch block so as to compute the intersection of initializations and
	// the minimum exit relative depth amongst all of them. Then consider the subroutine, and append its
	// initialization to the try/catch ones, if the subroutine completes normally. If the subroutine does not

		if (this.tryBlock.isEmptyBlock()) {
			tryInfo = flowInfo;
		} else {
			tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy(), false); // statements, ignore values
			if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
				this.bits |= ASTNode.IsTryBlockExiting;
		}

				if (this.tryBlock.statements == null) {
					catchInfo.setReachMode(FlowInfo.UNREACHABLE);
				}
				catchInfo = this.catchBlocks[i].analyseCode(currentScope, flowContext, catchInfo, false); // statements, ignore values
					this.catchBlocks[i].analyseCode(
						currentScope,
						flowContext,
						catchInfo);
				this.catchExitInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(catchInfo);
				this.catchExits[i] =
					(catchInfo.tagBits & FlowInfo.UNREACHABLE) != 0;

				.analyseCode(
					currentScope,
					finallyContext = new FinallyFlowContext(flowContext, this.finallyBlock),
					flowInfo.nullInfoLessUnconditionalCopy(),
				 	false)  // statements, ignore values
				.unconditionalInits();
		if (subInfo == FlowInfo.DEAD_END) {
			this.bits |= ASTNode.IsSubRoutineEscaping;

		if (this.tryBlock.isEmptyBlock()) {
			tryInfo = flowInfo;
		} else {
			tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy(), false); // statements, ignore values
			if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
				this.bits |= ASTNode.IsTryBlockExiting;
		}

				if (this.tryBlock.statements == null) {
					catchInfo.setReachMode(FlowInfo.UNREACHABLE);
				}
				catchInfo =	this.catchBlocks[i].analyseCode(currentScope, insideSubContext, catchInfo, false);  // statements, ignore values
					this.catchBlocks[i].analyseCode(
						currentScope,
						insideSubContext,
						catchInfo);
				this.catchExitInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(catchInfo);
				this.catchExits[i] =
					(catchInfo.tagBits & FlowInfo.UNREACHABLE) != 0;

Lines 187-193 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java (-1 / +1 lines)
187	* Flow analysis for a local innertype	187	* Flow analysis for a local innertype
188	*	188	*
189	*/	189	*/
190	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	190	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
191	if (this.ignoreFurtherInvestigation)	191	if (this.ignoreFurtherInvestigation)
192	return flowInfo;	192	return flowInfo;
193	try {	193	try {




package org.eclipse.jdt.internal.compiler.ast;

import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;

public void aboutToResolve(Scope scope) {
	// default implementation: do nothing
}
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
	return flowInfo;
}
public void checkBounds(Scope scope) {
	// only parameterized type references have bounds
}




		this.expression = expression;
		this.bits |= operator << OperatorSHIFT; // encode operator
	}
	public FlowInfo analyseCode(
			BlockScope currentScope,
			FlowContext flowContext,
			FlowInfo flowInfo, boolean valueRequired) {
		this.expression.checkNPE(currentScope, flowContext, flowInfo);
		if (((this.bits & OperatorMASK) >> OperatorSHIFT) == NOT) {
			return this.expression.
				analyseCode(currentScope, flowContext, flowInfo, valueRequired).
				asNegatedCondition();
		} else {
			return this.expression.
				analyseCode(currentScope, flowContext, flowInfo, valueRequired);
		}
	}
}

	public Constant optimizedBooleanConstant() {





		this.sourceEnd = e;
	}

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

		this.breakLabel = new BranchLabel();
		this.continueLabel = new BranchLabel();

				(condLoopContext =
					new LoopingFlowContext(flowContext, flowInfo, this, null,
						null, currentScope)),
				condInfo,
				!isConditionOptimizedFalse); // may optimize condition value if never entering the loop
		if ((this.condition.implicitConversion & TypeIds.UNBOXING) != 0) {
			this.condition.checkNPE(currentScope, flowContext, flowInfo);
		}

					condInfo.initsWhenTrue());

			if (this.action.complainIfUnreachable(actionInfo, currentScope, initialComplaintLevel) < Statement.COMPLAINED_UNREACHABLE) {
				actionInfo = this.action.analyseCode(currentScope, loopingContext, actionInfo, false); // statements, ignore values
			}

			// code generation can be optimized when no need to continue in the loop

	}

	public void resolve(BlockScope scope) {
		TypeBinding type = null;
		try {
			scope.isInsideCondition = true;
			type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);
		} finally  {
			scope.isInsideCondition = false;
		}
		this.condition.computeConversion(scope, type, type);
		if (this.action != null)
			this.action.resolve(scope);

Lines 35-40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (+2 lines)
35	// record the current case statement being processed (for entire switch case block).	35	// record the current case statement being processed (for entire switch case block).
36	public CaseStatement enclosingCase; // from 1.4 on, local types should not be accessed across switch case blocks (52221)	36	public CaseStatement enclosingCase; // from 1.4 on, local types should not be accessed across switch case blocks (52221)
37		37
		38	public boolean isInsideCondition = false;
		39
38	public final static VariableBinding[] EmulationPathToImplicitThis = {};	40	public final static VariableBinding[] EmulationPathToImplicitThis = {};
39	public final static VariableBinding[] NoEnclosingInstanceInConstructorCall = {};	41	public final static VariableBinding[] NoEnclosingInstanceInConstructorCall = {};
40		42

Lines 27-33 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/LocalVariableBinding.java (-1 / +1 lines)
27	public static final int UNUSED = 0;	27	public static final int UNUSED = 0;
28	public static final int USED = 1;	28	public static final int USED = 1;
29	public static final int FAKE_USED = 2;	29	public static final int FAKE_USED = 2;
30	public int useFlag; // for flow analysis (default is UNUSED), values < 0 indicate the number of compound uses (postIncrement or compoundAssignment)	30	public int useFlag; // for flow analysis (default is UNUSED)
31		31
32	public BlockScope declaringScope; // back-pointer to its declaring scope	32	public BlockScope declaringScope; // back-pointer to its declaring scope
33	public LocalDeclaration declaration; // for source-positions	33	public LocalDeclaration declaration; // for source-positions

Lines 35-42 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetReturnStatement.java (-2 / +2 lines)
35	super(expr, s, e);	35	super(expr, s, e);
36	}	36	}
37		37
38	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	38	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
39	FlowInfo info = super.analyseCode(currentScope, flowContext, flowInfo);	39	FlowInfo info = super.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
40	// we need to remove this optimization in order to prevent the inlining of the return bytecode	40	// we need to remove this optimization in order to prevent the inlining of the return bytecode
41	// 1GH0AU7: ITPJCORE:ALL - Eval - VerifyError in scrapbook page	41	// 1GH0AU7: ITPJCORE:ALL - Eval - VerifyError in scrapbook page
42	this.expression.bits &= ~IsReturnedValue;	42	this.expression.bits &= ~IsReturnedValue;

Lines 5950-5962 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java (-8 / +19 lines)
5950	+ " -warn:+null"	5950	+ " -warn:+null"
5951	+ " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",	5951	+ " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
5952	"",	5952	"",
5953	"----------\n" +	5953	"----------\n" +
5954	"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java (at line 4)\n" +	5954	"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java (at line 3)\n" +
5955	" if (o == null) {}\n" +	5955	" Object o = null;\n" +
5956	" ^\n" +	5956	" ^\n" +
5957	"Redundant null check: The variable o can only be null at this location\n" +	5957	"The value of the local variable o is not used\n" +
5958	"----------\n" +	5958	"----------\n" +
5959	"1 problem (1 warning)",	5959	"2. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java (at line 4)\n" +
		5960	" if (o == null) {}\n" +
		5961	" ^\n" +
		5962	"Redundant null check: The variable o can only be null at this location\n" +
		5963	"----------\n" +
		5964	"2 problems (2 warnings)",
5960	true);	5965	true);
5961	}	5966	}
5962	// null ref option	5967	// null ref option
Lines 5979-5985 Link Here
5979	+ " -warn:+nullDereference"	5984	+ " -warn:+nullDereference"
5980	+ " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",	5985	+ " -proceedOnError -referenceInfo -d \"" + OUTPUT_DIR + "\"",
5981	"",	5986	"",
5982	"",	5987	"----------\n" +
		5988	"1. WARNING in ---OUTPUT_DIR_PLACEHOLDER---/X.java (at line 3)\n" +
		5989	" Object o = null;\n" +
		5990	" ^\n" +
		5991	"The value of the local variable o is not used\n" +
		5992	"----------\n" +
		5993	"1 problem (1 warning)",
5983	true);	5994	true);
5984	}	5995	}
5985	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=190493	5996	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=190493

Lines 1836-1847 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/FlowAnalysisTest.java (-2 / +7 lines)
1836	" ^^^^^\n" +	1836	" ^^^^^\n" +
1837	"The type Local is never used locally\n" +	1837	"The type Local is never used locally\n" +
1838	"----------\n" +	1838	"----------\n" +
1839	"3. WARNING in X.java (at line 7)\n" +	1839	"3. WARNING in X.java (at line 5)\n" +
		1840	" int i = 12;\n" +
		1841	" ^\n" +
		1842	"The value of the field Local.i is not used\n" +
		1843	"----------\n" +
		1844	"4. WARNING in X.java (at line 7)\n" +
1840	" void method() {\n" +	1845	" void method() {\n" +
1841	" ^^^^^^^^\n" +	1846	" ^^^^^^^^\n" +
1842	"The method method() from the type Local is never used locally\n" +	1847	"The method method() from the type Local is never used locally\n" +
1843	"----------\n" +	1848	"----------\n" +
1844	"4. ERROR in X.java (at line 11)\n" +	1849	"5. ERROR in X.java (at line 11)\n" +
1845	" return;\n" +	1850	" return;\n" +
1846	" ^^^^^^^\n" +	1851	" ^^^^^^^\n" +
1847	"Unreachable code\n" +	1852	"Unreachable code\n" +




// Static initializer to specify tests subset using TESTS_* static variables
// All specified tests which do not belong to the class are skipped...
static {
//	TESTS_NAMES = new String[] { "test026" };
//	TESTS_NUMBERS = new int[] { 50, 51, 52, 53 };
//	TESTS_RANGE = new int[] { 34, 38 };
}

			"    void test() {\n" +
			"        for (Object object : array) {\n" +
			"            String str = object.toString();\n" +
			"            str += \"\";\n" + // try force 'str' to be preserved during codegen (can still be optimized out)
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +
			"        new X().test();\n" +
			"		System.out.println(\"SUCCESS\");\n" +
			"    }\n" +
			"}\n",
		},
		"SUCCESS");
}
// 68440 - verify error due to local variable invalid slot sharing
public void test026a() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    Object[] array = {\n" +
			"    };\n" +
			"    void test() {\n" +
			"        for (Object object : array) {\n" +
			"            String str = object.toString();\n" +
			"            System.out.print(str);\n" + // really force 'str' to be preserved during codegen
			"        }\n" +
			"    }\n" +
			"    public static void main(String[] args) {\n" +




  	// Only the highest compliance level is run; add the VM argument
  	// -Dcompliance=1.4 (for example) to lower it if needed
  	static {
//    	TESTS_NAMES = new String[] { "test0059" };
//		TESTS_NUMBERS = new int[] { 70 };
//  	TESTS_RANGE = new int[] { 1, -1 };
  	}


		customOptions,
		null);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SingleNameReference, local, postIncr, emptyThen
public void test0058()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.ERROR);	
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"	public void method() {\n" +
			"		int a=10;\n" +
			" 		if(a++ > 10) {\n" + // not counted as relevant use since bug 185682
			"		}\n" +   
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	int a=10;\n" + 
		"	    ^\n" + 
		"The value of the local variable a is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SingleNameReference, field, postIncr, emptyThenWithElse
public void test0059()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.ERROR);	
	customOptions.put(CompilerOptions.OPTION_ReportDeadCode, CompilerOptions.IGNORE);	
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"	private int a=10;\n" +
			"	public void method() {\n" +
			" 		if(true || (a++ > 10 && false)) {\n" + // not counted as relevant use since bug 185682
			"			System.out.println(\"OK\");\n" +   
			"		} else {\n" +   
			"			System.out.println(\"NOK\");\n" +   
			"		}\n" +   
			"   }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	private int a=10;\n" + 
		"	            ^\n" + 
		"The value of the field X.a is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// FieldReference, field, postIncr, optimizableCondition
public void test0060()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.ERROR);	
	customOptions.put(CompilerOptions.OPTION_ReportDeadCode, CompilerOptions.IGNORE);	
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"	private int a=10;\n" +
			"	public void method() {\n" +
			" 		if(this.a++ > 10 || true) {\n" + // not counted as relevant use since bug 185682
			"			System.out.println(\"OK\");\n" +
			"		}\n" +   
			"   }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	private int a=10;\n" + 
		"	            ^\n" + 
		"The value of the field X.a is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
}

// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SingleNameReference, local, simpleRead, emptyThen
public void test0061()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.ERROR);	
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"	public void method() {\n" +
			"		int a=10;\n" +
			" 		if(a > 10) {\n" +
			"		}\n" +   
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	int a=10;\n" + 
		"	    ^\n" + 
		"The value of the local variable a is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SingleNameReference, field, simpleRead, emptyThenWithElse
public void test0062()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.ERROR);	
	customOptions.put(CompilerOptions.OPTION_ReportDeadCode, CompilerOptions.IGNORE);	
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"	private int a=10;\n" +
			"	public void method() {\n" +
			" 		if(a > 10 && false) {\n" +
			"		} else {\n" +   
			"			System.out.println(\"OK\");\n" +   
			"		}\n" +   
			"   }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	private int a=10;\n" + 
		"	            ^\n" + 
		"The value of the field X.a is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// FieldReference+QualifiedNameReference, field, simpleRead, optimizableCondition
public void test0063()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.ERROR);	
	customOptions.put(CompilerOptions.OPTION_ReportDeadCode, CompilerOptions.IGNORE);	
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"	private int a=10;\n" +
			"	public void method(X other) {\n" +
			" 		if(this.a < 3 || true) {\n" +
			"			System.out.println(\"OK\");\n" +
			"		}\n" +   
			" 		if(other.a > 10 || true) {\n" +
			"			System.out.println(\"OK\");\n" +
			"		}\n" +   
			"   }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	private int a=10;\n" + 
		"	            ^\n" + 
		"The value of the field X.a is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// FieldReference+QualifiedNameReference, field, postIncr, optimizableCondition, exprOfForWhileDoSwitch
public void test0064()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.ERROR);	
	customOptions.put(CompilerOptions.OPTION_ReportDeadCode, CompilerOptions.IGNORE);	
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			" 	private int a=10;\n" +
			"	public void method(X other) {\n" +
			" 		for(;other.a++ > 10 && false;) {\n" +
			" 		}\n" +
			" 		while (true || this.a++>10) {\n" +
			" 		}\n" +
			" 		do {\n" +
			" 		} while (this.a++>10 && false);\n" +
			" 		switch(a++) {\n" +
			" 		}\n" +
			"   }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	private int a=10;\n" + 
		"	            ^\n" + 
		"The value of the field X.a is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SingleNameReference, argument, simpleRead, optimizableCondition, exprOfForWhileDoSwitch
public void test0065()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedParameter, CompilerOptions.ERROR);	
	customOptions.put(CompilerOptions.OPTION_ReportDeadCode, CompilerOptions.IGNORE);	
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"	public void method(int a) {\n" +
			" 		for(;a > 10 && false;) {\n" +
			" 		}\n" +
			" 		while (a>10 && false) {\n" +
			" 		}\n" +
			" 		do {\n" +
			" 		} while (a>10 && false);\n" +
			" 		switch(a) {\n" +
			" 		}\n" +   
			"   }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	public void method(int a) {\n" + 
		"	                       ^\n" + 
		"The value of the parameter a is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SimpleNameReference, localOfEnclosing, simpleRead, valueNeeded signaled by AbortMethod
public void test0066() throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"class X {\n" + 
			"    int bar() { return 23; }\n" +
			"    void foo() {\n" + 
			"        final int i=bar();\n" +
			"        new Runnable() {\n" +
			"            public void run() {\n" +
			"                if (i>3) { System.out.print(4); }\n" + 	// value is used
			"            }\n" + 
			"        }.run();\n" + 
			"    }\n" + 
			"}"
		},
		"",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		null,
		customOptions,
		null);
	String expectedOutput =
			"  // Method descriptor #6 ()V\n" + 
			"  // Stack: 4, Locals: 2\n" + 
			"  void foo();\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  invokevirtual X.bar() : int [17]\n" + 
			"     4  istore_1 [i]\n" + 
			"     5  new X$1 [19]\n" + 
			"     8  dup\n" + 
			"     9  aload_0 [this]\n" + 
			"    10  iload_1 [i]\n" + 
			"    11  invokespecial X$1(X, int) [21]\n" + 
			"    14  invokevirtual X$1.run() : void [24]\n" + 
			"    17  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 4]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"        [pc: 14, line: 9]\n" + 
			"        [pc: 17, line: 10]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 18] local: this index: 0 type: X\n" + 
			"        [pc: 5, pc: 18] local: i index: 1 type: int\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SimpleNameReference, localOfEnclosing, simpleRead, emptyThen
public void test0067() throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.WARNING);
	this.runNegativeTest(
		new String[] {
			"X.java",
			"class X {\n" + 
			"    int bar() { return 23; }\n" +
			"    void foo() {\n" + 
			"        final int i=bar();\n" +
			"        new Runnable() {\n" +
			"            public void run() {\n" +
			"                if (i>3) { }\n" + 	// value is optimized out
			"            }\n" + 
			"        }.run();\n" + 
			"    }\n" + 
			"}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\n" + 
		"	final int i=bar();\n" + 
		"	          ^\n" + 
		"The value of the local variable i is not used\n" + 
		"----------\n",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		customOptions);
	String expectedOutput =
			"  // Method descriptor #6 ()V\n" + 
			"  // Stack: 3, Locals: 1\n" + 
			"  void foo();\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  invokevirtual X.bar() : int [17]\n" + 
			"     4  pop\n" + 
			"     5  new X$1 [19]\n" + 
			"     8  dup\n" + 
			"     9  aload_0 [this]\n" + 
			"    10  invokespecial X$1(X) [21]\n" + 
			"    13  invokevirtual X$1.run() : void [24]\n" + 
			"    16  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 4]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"        [pc: 13, line: 9]\n" + 
			"        [pc: 16, line: 10]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 17] local: this index: 0 type: X\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SingleNameReference, local, assignmentAsExpression, emptyThen
public void test0068()  throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.WARNING);	
	this.runNegativeTest(
			new String[] {
				"X.java",
				"public class X {\n" +
				"	public void method() {\n" +
				"		int a=10;\n" +
				"		int b;\n" +
				" 		if((b=a) > 10) {\n" +
				"		}\n" +   
				"    }\n" +
				"}\n"
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 4)\n" + 
			"	int b;\n" + 
			"	    ^\n" + 
			"The value of the local variable b is not used\n" + 
			"----------\n",
			null/*classLibraries*/,
			true/*shouldFlushOutputDirectory*/,
			customOptions);
	String expectedOutput =
			"  // Method descriptor #6 ()V\n" + 
			"  // Stack: 1, Locals: 2\n" + 
			"  public void method();\n" + 
			"    0  bipush 10\n" + 
			"    2  istore_1 [a]\n" + 
			"    3  iload_1 [a]\n" + 
			"    4  pop\n" + 
			"    5  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 3]\n" + 
			"        [pc: 3, line: 5]\n" + 
			"        [pc: 5, line: 7]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 6] local: this index: 0 type: X\n" + 
			"        [pc: 3, pc: 6] local: a index: 1 type: int\n"; // b has been optimized out
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SimpleNameReference, localOfEnclosing, simpleRead, valueNeeded from local type
public void test0069() throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.IGNORE);
	this.runConformTest(
			new String[] {
					"X.java",
					"public class X {\n" + 
					"    int bar() { return 23; }\n" +
					"    void foo() {\n" + 
					"        final int i=bar();\n" +
					"        new Runnable() {\n" +
					"            public void run() {\n" +
					"                if (i>3) {}\n" + 	// value is not used
					"                System.out.print(4);\n" +
					"            }\n" + 
					"        }.run();\n" + 
					"    }\n" + 
					"	public static void main(String[] args) {\n" +
					"		new  X().foo();\n" +
					"	}\n" +
					"}"
			},
			"4",
			null/*classLibraries*/,
			true/*shouldFlushOutputDirectory*/,
			null,
			customOptions,
			null);
	String expectedOutput =
			"  // Method descriptor #6 ()V\n" + 
			"  // Stack: 3, Locals: 1\n" + 
			"  void foo();\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  invokevirtual X.bar() : int [17]\n" + 
			"     4  pop\n" + 
			"     5  new X$1 [19]\n" + 
			"     8  dup\n" + 
			"     9  aload_0 [this]\n" + 
			"    10  invokespecial X$1(X) [21]\n" + 
			"    13  invokevirtual X$1.run() : void [24]\n" + 
			"    16  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 4]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"        [pc: 13, line: 10]\n" + 
			"        [pc: 16, line: 11]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 17] local: this index: 0 type: X\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
	if (this.complianceLevel < ClassFileConstants.JDK1_4) {
		expectedOutput =
			"  // Method descriptor #11 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  invokespecial java.lang.Object() [13]\n" + 
			"     4  aload_0 [this]\n" + 
			"     5  aload_1 [arg0]\n" + 
			"     6  putfield X$1.this$0 : X [16]\n" + 
			"     9  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 5]\n" + 
			"        [pc: 4, line: 1]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 10] local: this index: 0 type: new X(){}\n";
	} else if (this.complianceLevel < ClassFileConstants.JDK1_5) {
		expectedOutput =
			"  // Method descriptor #11 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  aload_1 [arg0]\n" + 
			"     2  putfield X$1.this$0 : X [13]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [15]\n" + 
			"     9  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 1]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 10] local: this index: 0 type: new X(){}\n";
	} else {
		expectedOutput =
			"  // Method descriptor #10 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  aload_1 [arg0]\n" + 
			"     2  putfield X$1.this$0 : X [12]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [14]\n" + 
			"     9  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 1]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 10] local: this index: 0 type: new X(){}\n";
	}
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X$1.class", "X$1", expectedOutput);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SimpleNameReference, localOfEnclosing, simpleRead, valueNeeded from local type
public void test0070() throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.IGNORE);
	this.runConformTest(
			new String[] {
				"X.java",
				"public class X {\n" + 
				"    int bar() { return 23; }\n" +
				"    public X() {\n" + 
				"        final int i=bar();\n" +
				"        new Runnable() {\n" +
				"            public void run() {\n" +
				"                if (i>3) {}\n" + 	// value is not used
				"                System.out.print(4);\n" +
				"            }\n" + 
				"        }.run();\n" + 
				"    }\n" + 
				"	public static void main(String[] args) {\n" +
				"		new  X();\n" +
				"	}\n" +
				"}"
		},
		"4",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		null,
		customOptions,
		null);
	String expectedOutput =
			"  // Method descriptor #13 ()V\n" + 
			"  // Stack: 3, Locals: 1\n" + 
			"  public X();\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  invokespecial java.lang.Object() [14]\n" + 
			"     4  aload_0 [this]\n" + 
			"     5  invokevirtual X.bar() : int [16]\n" + 
			"     8  pop\n" + 
			"     9  new X$1 [18]\n" + 
			"    12  dup\n" + 
			"    13  aload_0 [this]\n" + 
			"    14  invokespecial X$1(X) [20]\n" + 
			"    17  invokevirtual X$1.run() : void [23]\n" + 
			"    20  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 3]\n" + 
			"        [pc: 4, line: 4]\n" + 
			"        [pc: 9, line: 5]\n" + 
			"        [pc: 17, line: 10]\n" + 
			"        [pc: 20, line: 11]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 21] local: this index: 0 type: X\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
	if (this.complianceLevel < ClassFileConstants.JDK1_4) {
		expectedOutput =
			"  // Method descriptor #11 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  invokespecial java.lang.Object() [13]\n" + 
			"     4  aload_0 [this]\n" + 
			"     5  aload_1 [arg0]\n" + 
			"     6  putfield X$1.this$0 : X [16]\n" + 
			"     9  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 5]\n" + 
			"        [pc: 4, line: 1]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 10] local: this index: 0 type: new X(){}\n";
	} else if (this.complianceLevel < ClassFileConstants.JDK1_5) {
		expectedOutput =
			"  // Method descriptor #11 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  aload_1 [arg0]\n" + 
			"     2  putfield X$1.this$0 : X [13]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [15]\n" + 
			"     9  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 1]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 10] local: this index: 0 type: new X(){}\n";
	} else {
		expectedOutput =
			"  // Method descriptor #10 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  aload_1 [arg0]\n" + 
			"     2  putfield X$1.this$0 : X [12]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [14]\n" + 
			"     9  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 1]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 10] local: this index: 0 type: new X(){}\n";
	}
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X$1.class", "X$1", expectedOutput);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SimpleNameReference, localOfEnclosing, simpleRead, valueNeeded from local type
public void test0071() throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X {\n" + 
			"    int bar() { return 23; }\n" +
			"    X() {\n" + 
			"        final int i=bar();\n" +
			"        new Runnable() {\n" +
			"            public void run() {\n" +
			"                if (i>3) { System.out.print(4); }\n" + 	// value is used
			"            }\n" + 
			"        }.run();\n" + 
			"    }\n" + 
			"	public static void main(String[] args) {\n" +
			"		new  X();\n" +
			"	}\n" +
			"}"
		},
		"4",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		null,
		customOptions,
		null);
	String expectedOutput =
		"  // Method descriptor #13 ()V\n" + 
		"  // Stack: 4, Locals: 2\n" + 
		"  X();\n" + 
		"     0  aload_0 [this]\n" + 
		"     1  invokespecial java.lang.Object() [14]\n" + 
		"     4  aload_0 [this]\n" + 
		"     5  invokevirtual X.bar() : int [16]\n" + 
		"     8  istore_1 [i]\n" + 
		"     9  new X$1 [18]\n" + 
		"    12  dup\n" + 
		"    13  aload_0 [this]\n" + 
		"    14  iload_1 [i]\n" + 
		"    15  invokespecial X$1(X, int) [20]\n" + 
		"    18  invokevirtual X$1.run() : void [23]\n" + 
		"    21  return\n" + 
		"      Line numbers:\n" + 
		"        [pc: 0, line: 3]\n" + 
		"        [pc: 4, line: 4]\n" + 
		"        [pc: 9, line: 5]\n" + 
		"        [pc: 18, line: 9]\n" + 
		"        [pc: 21, line: 10]\n" + 
		"      Local variable table:\n" + 
		"        [pc: 0, pc: 22] local: this index: 0 type: X\n" + 
		"        [pc: 9, pc: 22] local: i index: 1 type: int\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
	if (this.complianceLevel < ClassFileConstants.JDK1_4) {
		expectedOutput =
				"  // Method descriptor #13 (LX;I)V\n" + 
				"  // Stack: 2, Locals: 3\n" + 
				"  X$1(X arg0, int arg1);\n" + 
				"     0  aload_0 [this]\n" + 
				"     1  invokespecial java.lang.Object() [15]\n" + 
				"     4  aload_0 [this]\n" + 
				"     5  aload_1 [arg0]\n" + 
				"     6  putfield X$1.this$0 : X [18]\n" + 
				"     9  aload_0 [this]\n" + 
				"    10  iload_2 [arg1]\n" + 
				"    11  putfield X$1.val$i : int [20]\n" + 
				"    14  return\n" + 
				"      Line numbers:\n" + 
				"        [pc: 0, line: 5]\n" + 
				"        [pc: 4, line: 1]\n" + 
				"      Local variable table:\n" + 
				"        [pc: 0, pc: 15] local: this index: 0 type: new X(){}\n";
	} else if (this.complianceLevel < ClassFileConstants.JDK1_5) {
		expectedOutput =
				"  // Method descriptor #13 (LX;I)V\n" + 
				"  // Stack: 2, Locals: 3\n" + 
				"  X$1(X arg0, int arg1);\n" + 
				"     0  aload_0 [this]\n" + 
				"     1  aload_1 [arg0]\n" + 
				"     2  putfield X$1.this$0 : X [15]\n" + 
				"     5  aload_0 [this]\n" + 
				"     6  iload_2 [arg1]\n" + 
				"     7  putfield X$1.val$i : int [17]\n" + 
				"    10  aload_0 [this]\n" + 
				"    11  invokespecial java.lang.Object() [19]\n" + 
				"    14  return\n" + 
				"      Line numbers:\n" + 
				"        [pc: 0, line: 1]\n" + 
				"        [pc: 10, line: 5]\n" + 
				"      Local variable table:\n" + 
				"        [pc: 0, pc: 15] local: this index: 0 type: new X(){}\n";
	} else {
		expectedOutput =
				"  // Method descriptor #12 (LX;I)V\n" + 
				"  // Stack: 2, Locals: 3\n" + 
				"  X$1(X arg0, int arg1);\n" + 
				"     0  aload_0 [this]\n" + 
				"     1  aload_1 [arg0]\n" + 
				"     2  putfield X$1.this$0 : X [14]\n" + 
				"     5  aload_0 [this]\n" + 
				"     6  iload_2 [arg1]\n" + 
				"     7  putfield X$1.val$i : int [16]\n" + 
				"    10  aload_0 [this]\n" + 
				"    11  invokespecial java.lang.Object() [18]\n" + 
				"    14  return\n" + 
				"      Line numbers:\n" + 
				"        [pc: 0, line: 1]\n" + 
				"        [pc: 10, line: 5]\n" + 
				"      Local variable table:\n" + 
				"        [pc: 0, pc: 15] local: this index: 0 type: new X(){}\n";
	}
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X$1.class", "X$1", expectedOutput);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SimpleNameReference, localOfEnclosing, simpleRead, valueNeeded from local type
public void test0072() throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.ERROR);
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X {\n" + 
			"    int bar() { return 23; }\n" +
			"    X() {\n" + 
			"        final int i=bar();\n" +
			"        new Runnable() {\n" +
			"            {\n" +
			"                if (i>3) { System.out.print(4); }\n" + 	// value is used
			"            }\n" + 
			"            public void run() {\n" +
			"            }\n" + 
			"        }.run();\n" + 
			"    }\n" + 
			"	public static void main(String[] args) {\n" +
			"		new  X();\n" +
			"	}\n" +
			"}"
		},
		"4",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		null,
		customOptions,
		null);
	String expectedOutput =
		"  // Method descriptor #13 ()V\n" + 
		"  // Stack: 4, Locals: 2\n" + 
		"  X();\n" + 
		"     0  aload_0 [this]\n" + 
		"     1  invokespecial java.lang.Object() [14]\n" + 
		"     4  aload_0 [this]\n" + 
		"     5  invokevirtual X.bar() : int [16]\n" + 
		"     8  istore_1 [i]\n" + 
		"     9  new X$1 [18]\n" + 
		"    12  dup\n" + 
		"    13  aload_0 [this]\n" + 
		"    14  iload_1 [i]\n" + 
		"    15  invokespecial X$1(X, int) [20]\n" + 
		"    18  invokevirtual X$1.run() : void [23]\n" + 
		"    21  return\n" + 
		"      Line numbers:\n" + 
		"        [pc: 0, line: 3]\n" + 
		"        [pc: 4, line: 4]\n" + 
		"        [pc: 9, line: 5]\n" + 
		"        [pc: 18, line: 11]\n" + 
		"        [pc: 21, line: 12]\n" + 
		"      Local variable table:\n" + 
		"        [pc: 0, pc: 22] local: this index: 0 type: X\n" + 
		"        [pc: 9, pc: 22] local: i index: 1 type: int\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
	if (this.complianceLevel < ClassFileConstants.JDK1_4) {
		expectedOutput =
			"  // Method descriptor #11 (LX;I)V\n" + 
			"  // Stack: 2, Locals: 3\n" + 
			"  X$1(X arg0, int arg1);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  invokespecial java.lang.Object() [13]\n" + 
			"     4  aload_0 [this]\n" + 
			"     5  aload_1 [arg0]\n" + 
			"     6  putfield X$1.this$0 : X [16]\n" + 
			"     9  iload_2 [arg1]\n" + 
			"    10  iconst_3\n" + 
			"    11  if_icmple 21\n" + 
			"    14  getstatic java.lang.System.out : java.io.PrintStream [18]\n" + 
			"    17  iconst_4\n" + 
			"    18  invokevirtual java.io.PrintStream.print(int) : void [24]\n" + 
			"    21  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 5]\n" + 
			"        [pc: 9, line: 7]\n" + 
			"        [pc: 21, line: 1]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 22] local: this index: 0 type: new X(){}\n";
	} else if (this.complianceLevel < ClassFileConstants.JDK1_5) {
		expectedOutput =
			"  // Method descriptor #11 (LX;I)V\n" + 
			"  // Stack: 2, Locals: 3\n" + 
			"  X$1(X arg0, int arg1);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  aload_1 [arg0]\n" + 
			"     2  putfield X$1.this$0 : X [13]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [15]\n" + 
			"     9  iload_2 [arg1]\n" + 
			"    10  iconst_3\n" + 
			"    11  if_icmple 21\n" + 
			"    14  getstatic java.lang.System.out : java.io.PrintStream [18]\n" + 
			"    17  iconst_4\n" + 
			"    18  invokevirtual java.io.PrintStream.print(int) : void [24]\n" + 
			"    21  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 1]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"        [pc: 9, line: 7]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 22] local: this index: 0 type: new X(){}\n";
	} else {
		expectedOutput =
			"  // Method descriptor #10 (LX;I)V\n" + 
			"  // Stack: 2, Locals: 3\n" + 
			"  X$1(X arg0, int arg1);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  aload_1 [arg0]\n" + 
			"     2  putfield X$1.this$0 : X [12]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [14]\n" + 
			"     9  iload_2 [arg1]\n" + 
			"    10  iconst_3\n" + 
			"    11  if_icmple 21\n" + 
			"    14  getstatic java.lang.System.out : java.io.PrintStream [17]\n" + 
			"    17  iconst_4\n" + 
			"    18  invokevirtual java.io.PrintStream.print(int) : void [23]\n" + 
			"    21  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 1]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"        [pc: 9, line: 7]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 22] local: this index: 0 type: new X(){}\n";
	}
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X$1.class", "X$1", expectedOutput);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// SimpleNameReference, localOfEnclosing, simpleRead, valueNeeded from local type
public void test0073() throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.IGNORE);
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X {\n" + 
			"    int bar() { return 23; }\n" +
			"    X() {\n" + 
			"        final int i=bar();\n" +
			"        new Runnable() {\n" +
			"            {\n" +
			"                if (i>3) {}\n" + 	// value is not used
			"                System.out.print(4);\n" +
			"            }\n" + 
			"            public void run() {\n" +
			"            }\n" + 
			"        }.run();\n" + 
			"    }\n" + 
			"	public static void main(String[] args) {\n" +
			"		new  X();\n" +
			"	}\n" +
			"}"
		},
		"4",
		null/*classLibraries*/,
		true/*shouldFlushOutputDirectory*/,
		null,
		customOptions,
		null);
	String expectedOutput =
		"  // Method descriptor #13 ()V\n" + 
		"  // Stack: 3, Locals: 1\n" + 
		"  X();\n" + 
		"     0  aload_0 [this]\n" + 
		"     1  invokespecial java.lang.Object() [14]\n" + 
		"     4  aload_0 [this]\n" + 
		"     5  invokevirtual X.bar() : int [16]\n" + 
		"     8  pop\n" + 
		"     9  new X$1 [18]\n" + 
		"    12  dup\n" + 
		"    13  aload_0 [this]\n" + 
		"    14  invokespecial X$1(X) [20]\n" + 
		"    17  invokevirtual X$1.run() : void [23]\n" + 
		"    20  return\n" + 
		"      Line numbers:\n" + 
		"        [pc: 0, line: 3]\n" + 
		"        [pc: 4, line: 4]\n" + 
		"        [pc: 9, line: 5]\n" + 
		"        [pc: 17, line: 12]\n" + 
		"        [pc: 20, line: 13]\n" + 
		"      Local variable table:\n" + 
		"        [pc: 0, pc: 21] local: this index: 0 type: X\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
	if (this.complianceLevel < ClassFileConstants.JDK1_4) {
		expectedOutput =
			"  // Method descriptor #11 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  invokespecial java.lang.Object() [13]\n" + 
			"     4  aload_0 [this]\n" + 
			"     5  aload_1 [arg0]\n" + 
			"     6  putfield X$1.this$0 : X [16]\n" + 
			"     9  getstatic java.lang.System.out : java.io.PrintStream [18]\n" + 
			"    12  iconst_4\n" + 
			"    13  invokevirtual java.io.PrintStream.print(int) : void [24]\n" + 
			"    16  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 5]\n" + 
			"        [pc: 9, line: 8]\n" + 
			"        [pc: 16, line: 1]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 17] local: this index: 0 type: new X(){}\n";
	} else if (this.complianceLevel < ClassFileConstants.JDK1_5) {
		expectedOutput =
			"  // Method descriptor #11 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  aload_1 [arg0]\n" + 
			"     2  putfield X$1.this$0 : X [13]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [15]\n" + 
			"     9  getstatic java.lang.System.out : java.io.PrintStream [18]\n" + 
			"    12  iconst_4\n" + 
			"    13  invokevirtual java.io.PrintStream.print(int) : void [24]\n" + 
			"    16  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 1]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"        [pc: 9, line: 8]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 17] local: this index: 0 type: new X(){}\n";
	} else {
		expectedOutput =
			"  // Method descriptor #10 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\n" + 
			"     0  aload_0 [this]\n" + 
			"     1  aload_1 [arg0]\n" + 
			"     2  putfield X$1.this$0 : X [12]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [14]\n" + 
			"     9  getstatic java.lang.System.out : java.io.PrintStream [17]\n" + 
			"    12  iconst_4\n" + 
			"    13  invokevirtual java.io.PrintStream.print(int) : void [23]\n" + 
			"    16  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 1]\n" + 
			"        [pc: 5, line: 5]\n" + 
			"        [pc: 9, line: 8]\n" + 
			"      Local variable table:\n" + 
			"        [pc: 0, pc: 17] local: this index: 0 type: new X(){}\n";
	}
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X$1.class", "X$1", expectedOutput);
}
// https://bugs.eclipse.org/328830  -  Variable should be marked unused when it can be optimized out
// white box against an intermediate patch: testing that double analysis of a condition may harm
public void test0074() throws Exception {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.WARNING);	
	this.runNegativeTest(
			new String[] {
				"X.java",
				"public class X {\n" +
				"	public void method() {\n" +
				"		int a=10;\n" +
				"		final int b;\n" +
				" 		if((b=a) > 10) {\n" +
				"           System.out.print(3);\n" +
				"		}\n" +   
				"    }\n" +
				"}\n"
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 4)\n" + 
			"	final int b;\n" + 
			"	          ^\n" + 
			"The value of the local variable b is not used\n" + 
			"----------\n",
			null/*classLibraries*/,
			true/*shouldFlushOutputDirectory*/,
			customOptions);	
}
}

Return to bug 328830

Lines 27-33 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AND_AND_Expression.java (-5 / +5 lines)
27	super(left, right, operator);	27	super(left, right, operator);
28	}	28	}
29		29
30	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	30	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
31		31
32	Constant cst = this.left.optimizedBooleanConstant();	32	Constant cst = this.left.optimizedBooleanConstant();
33	boolean isLeftOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;	33	boolean isLeftOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;
Lines 38-52 Link Here
38	// need to be careful of scenario:	38	// need to be careful of scenario:
39	// (x && y) && !z, if passing the left info to the right, it would	39	// (x && y) && !z, if passing the left info to the right, it would
40	// be swapped by the !	40	// be swapped by the !
41	FlowInfo mergedInfo = this.left.analyseCode(currentScope, flowContext, flowInfo)	41	FlowInfo mergedInfo = this.left.analyseCode(currentScope, flowContext, flowInfo, false) // subject to optimization
42	.unconditionalInits();	42	.unconditionalInits();
43	mergedInfo = this.right.analyseCode(currentScope, flowContext, mergedInfo);	43	mergedInfo = this.right.analyseCode(currentScope, flowContext, mergedInfo, valueRequired);
44	this.mergedInitStateIndex = currentScope.methodScope()	44	this.mergedInitStateIndex = currentScope.methodScope()
45	.recordInitializationStates(mergedInfo);	45	.recordInitializationStates(mergedInfo);
46	return mergedInfo;	46	return mergedInfo;
47	}	47	}
48		48
49	FlowInfo leftInfo = this.left.analyseCode(currentScope, flowContext, flowInfo);	49	FlowInfo leftInfo = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
50	// need to be careful of scenario:	50	// need to be careful of scenario:
51	// (x && y) && !z, if passing the left info to the right, it would be	51	// (x && y) && !z, if passing the left info to the right, it would be
52	// swapped by the !	52	// swapped by the !
Lines 60-66 Link Here
60	rightInfo.setReachMode(FlowInfo.UNREACHABLE);	60	rightInfo.setReachMode(FlowInfo.UNREACHABLE);
61	}	61	}
62	}	62	}
63	rightInfo = this.right.analyseCode(currentScope, flowContext, rightInfo);	63	rightInfo = this.right.analyseCode(currentScope, flowContext, rightInfo, !isLeftOptimizedFalse); // unused if left is false
64	if ((this.left.implicitConversion & TypeIds.UNBOXING) != 0) {	64	if ((this.left.implicitConversion & TypeIds.UNBOXING) != 0) {
65	this.left.checkNPE(currentScope, flowContext, flowInfo);	65	this.left.checkNPE(currentScope, flowContext, flowInfo);
66	}	66	}

Lines 26-43 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayAllocationExpression.java (-3 / +5 lines)
26	public Expression[] dimensions;	26	public Expression[] dimensions;
27	public ArrayInitializer initializer;	27	public ArrayInitializer initializer;
28		28
29	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	29	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		30	// allocation itself has no side effect => may optimize all child nodes
		31
30	for (int i = 0, max = this.dimensions.length; i < max; i++) {	32	for (int i = 0, max = this.dimensions.length; i < max; i++) {
31	Expression dim;	33	Expression dim;
32	if ((dim = this.dimensions[i]) != null) {	34	if ((dim = this.dimensions[i]) != null) {
33	flowInfo = dim.analyseCode(currentScope, flowContext, flowInfo);	35	flowInfo = dim.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
34	if ((dim.implicitConversion & TypeIds.UNBOXING) != 0) {	36	if ((dim.implicitConversion & TypeIds.UNBOXING) != 0) {
35	dim.checkNPE(currentScope, flowContext, flowInfo);	37	dim.checkNPE(currentScope, flowContext, flowInfo);
36	}	38	}
37	}	39	}
38	}	40	}
39	if (this.initializer != null) {	41	if (this.initializer != null) {
40	return this.initializer.analyseCode(currentScope, flowContext, flowInfo);	42	return this.initializer.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
41	}	43	}
42	return flowInfo;	44	return flowInfo;
43	}	45	}

Lines 29-39 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayInitializer.java (-2 / +3 lines)
29	super();	29	super();
30	}	30	}
31		31
32	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	32	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		33	// initializer itself has no side effect => may optimize all child nodes
33		34
34	if (this.expressions != null) {	35	if (this.expressions != null) {
35	for (int i = 0, max = this.expressions.length; i < max; i++) {	36	for (int i = 0, max = this.expressions.length; i < max; i++) {
36	flowInfo = this.expressions[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	37	flowInfo = this.expressions[i].analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits();
37	}	38	}
38	}	39	}
39	return flowInfo;	40	return flowInfo;

Lines 31-53 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ArrayReference.java (-7 / +9 lines)
31	this.sourceStart = rec.sourceStart;	31	this.sourceStart = rec.sourceStart;
32	}	32	}
33		33
34	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean compoundAssignment) {	34	public FlowInfo analyseAssignment(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, Assignment assignment, boolean compoundAssignment, boolean valueRequired) {
		35	// array assignment has a side effect => require values from all child nodes
		36
35	// TODO (maxime) optimization: unconditionalInits is applied to all existing calls	37	// TODO (maxime) optimization: unconditionalInits is applied to all existing calls
36	if (assignment.expression == null) {	38	if (assignment.expression == null) {
37	return analyseCode(currentScope, flowContext, flowInfo);	39	return analyseCode(currentScope, flowContext, flowInfo, true);
38	}	40	}
39	return assignment	41	return assignment
40	.expression	42	.expression
41	.analyseCode(	43	.analyseCode(
42	currentScope,	44	currentScope,
43	flowContext,	45	flowContext,
44	analyseCode(currentScope, flowContext, flowInfo).unconditionalInits());	46	analyseCode(currentScope, flowContext, flowInfo, true).unconditionalInits(), true);
45	}	47	}
46		48	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
47	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	49	// reference itself has no side effect => may optimize all child nodes
48	this.receiver.checkNPE(currentScope, flowContext, flowInfo);	50	this.receiver.checkNPE(currentScope, flowContext, flowInfo);
49	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo);	51	flowInfo = this.receiver.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
50	return this.position.analyseCode(currentScope, flowContext, flowInfo);	52	return this.position.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
51	}	53	}
52		54
53	public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {	55	public void generateAssignment(BlockScope currentScope, CodeStream codeStream, Assignment assignment, boolean valueRequired) {

Lines 40-46 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AssertStatement.java (-3 / +4 lines)
40	this.sourceEnd = assertExpression.sourceEnd;	40	this.sourceEnd = assertExpression.sourceEnd;
41	}	41	}
42		42
43	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	43	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		44	// assert may have side effect (throwing) => require values from all child nodes
44	this.preAssertInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);	45	this.preAssertInitStateIndex = currentScope.methodScope().recordInitializationStates(flowInfo);
45		46
46	Constant cst = this.assertExpression.optimizedBooleanConstant();	47	Constant cst = this.assertExpression.optimizedBooleanConstant();
Lines 51-57 Link Here
51	boolean isOptimizedFalseAssertion = cst != Constant.NotAConstant && cst.booleanValue() == false;	52	boolean isOptimizedFalseAssertion = cst != Constant.NotAConstant && cst.booleanValue() == false;
52		53
53	flowContext.tagBits \|= FlowContext.HIDE_NULL_COMPARISON_WARNING;	54	flowContext.tagBits \|= FlowContext.HIDE_NULL_COMPARISON_WARNING;
54	FlowInfo conditionFlowInfo = this.assertExpression.analyseCode(currentScope, flowContext, flowInfo.copy());	55	FlowInfo conditionFlowInfo = this.assertExpression.analyseCode(currentScope, flowContext, flowInfo.copy(), true);
55	flowContext.tagBits &= ~FlowContext.HIDE_NULL_COMPARISON_WARNING;	56	flowContext.tagBits &= ~FlowContext.HIDE_NULL_COMPARISON_WARNING;
56	UnconditionalFlowInfo assertWhenTrueInfo = conditionFlowInfo.initsWhenTrue().unconditionalInits();	57	UnconditionalFlowInfo assertWhenTrueInfo = conditionFlowInfo.initsWhenTrue().unconditionalInits();
57	FlowInfo assertInfo = conditionFlowInfo.initsWhenFalse();	58	FlowInfo assertInfo = conditionFlowInfo.initsWhenFalse();
Lines 61-67 Link Here
61		62
62	if (this.exceptionArgument != null) {	63	if (this.exceptionArgument != null) {
63	// only gets evaluated when escaping - results are not taken into account	64	// only gets evaluated when escaping - results are not taken into account
64	FlowInfo exceptionInfo = this.exceptionArgument.analyseCode(currentScope, flowContext, assertInfo.copy());	65	FlowInfo exceptionInfo = this.exceptionArgument.analyseCode(currentScope, flowContext, assertInfo.copy(), true);
65		66
66	if (isOptimizedTrueAssertion){	67	if (isOptimizedTrueAssertion){
67	currentScope.problemReporter().fakeReachable(this.exceptionArgument);	68	currentScope.problemReporter().fakeReachable(this.exceptionArgument);

Lines 56-73 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/BinaryExpression.java (-4 / +4 lines)
56	this.sourceStart = expression.sourceStart;	56	this.sourceStart = expression.sourceStart;
57	this.sourceEnd = expression.sourceEnd;	57	this.sourceEnd = expression.sourceEnd;
58	}	58	}
59	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	59	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
60	// keep implementation in sync with CombinedBinaryExpression#analyseCode	60	// keep implementation in sync with CombinedBinaryExpression#analyseCode
61	if (this.resolvedType.id == TypeIds.T_JavaLangString) {	61	if (this.resolvedType.id == TypeIds.T_JavaLangString) {
62	return this.right.analyseCode(	62	return this.right.analyseCode(
63	currentScope, flowContext,	63	currentScope, flowContext,
64	this.left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits())	64	this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits(), valueRequired)
65	.unconditionalInits();	65	.unconditionalInits();
66	} else {	66	} else {
67	this.left.checkNPE(currentScope, flowContext, flowInfo);	67	this.left.checkNPE(currentScope, flowContext, flowInfo);
68	flowInfo = this.left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	68	flowInfo = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits();
69	this.right.checkNPE(currentScope, flowContext, flowInfo);	69	this.right.checkNPE(currentScope, flowContext, flowInfo);
70	return this.right.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	70	return this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits();
71	}	71	}
72	}	72	}
73		73

Lines 26-39 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (-2 / +2 lines)
26	this.explicitDeclarations = explicitDeclarations;	26	this.explicitDeclarations = explicitDeclarations;
27	}	27	}
28		28
29	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	29	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
30	// empty block	30	// empty block
31	if (this.statements == null) return flowInfo;	31	if (this.statements == null) return flowInfo;
32	int complaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;	32	int complaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;
33	for (int i = 0, max = this.statements.length; i < max; i++) {	33	for (int i = 0, max = this.statements.length; i < max; i++) {
34	Statement stat = this.statements[i];	34	Statement stat = this.statements[i];
35	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {	35	if ((complaintLevel = stat.complainIfUnreachable(flowInfo, this.scope, complaintLevel)) < Statement.COMPLAINED_UNREACHABLE) {
36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);	36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo, false);
37	}	37	}
38	}	38	}
39	return flowInfo;	39	return flowInfo;

Lines 35-51 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/CaseStatement.java (-5 / +2 lines)
35	this.sourceStart = sourceStart;	35	this.sourceStart = sourceStart;
36	}	36	}
37		37
38	public FlowInfo analyseCode(	38	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
39	BlockScope currentScope,
40	FlowContext flowContext,
41	FlowInfo flowInfo) {
42		39
43	if (this.constantExpression != null) {	40	if (this.constantExpression != null) {
44	if (this.constantExpression.constant == Constant.NotAConstant	41	if (this.constantExpression.constant == Constant.NotAConstant
45	&& !this.constantExpression.resolvedType.isEnum()) {	42	&& !this.constantExpression.resolvedType.isEnum()) {
46	currentScope.problemReporter().caseExpressionMustBeConstant(this.constantExpression);	43	currentScope.problemReporter().caseExpressionMustBeConstant(this.constantExpression);
47	}	44	}
48	this.constantExpression.analyseCode(currentScope, flowContext, flowInfo);	45	this.constantExpression.analyseCode(currentScope, flowContext, flowInfo, true); // nothing to optimize here
49	}	46	}
50	return flowInfo;	47	return flowInfo;
51	}	48	}

Lines 34-49 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/CompoundAssignment.java (-9 / +9 lines)
34	this.operator = operator ;	34	this.operator = operator ;
35	}	35	}
36		36
37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,	37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
38	FlowInfo flowInfo) {	38	FlowInfo flowInfo, boolean valueRequired) {
39	// record setting a variable: various scenarii are possible, setting an array reference,	39	// record setting a variable: various scenarii are possible, setting an array reference,
40	// a field reference, a blank final field reference, a field of an enclosing instance or	40	// a field reference, a blank final field reference, a field of an enclosing instance or
41	// just a local variable.	41	// just a local variable.
42	if (this.resolvedType.id != T_JavaLangString) {	42	if (this.resolvedType.id != T_JavaLangString) {
43	this.lhs.checkNPE(currentScope, flowContext, flowInfo);	43	this.lhs.checkNPE(currentScope, flowContext, flowInfo);
		44	}
		45	return ((Reference) this.lhs).analyseAssignment(currentScope, flowContext, flowInfo, this, true, valueRequired).unconditionalInits();
44	}	46	}
45	return ((Reference) this.lhs).analyseAssignment(currentScope, flowContext, flowInfo, this, true).unconditionalInits();
46	}
47		47
48	public boolean checkCastCompatibility() {	48	public boolean checkCastCompatibility() {
49	return true;	49	return true;

Lines 40-55 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ConditionalExpression.java (-6 / +5 lines)
40	this.sourceStart = condition.sourceStart;	40	this.sourceStart = condition.sourceStart;
41	this.sourceEnd = valueIfFalse.sourceEnd;	41	this.sourceEnd = valueIfFalse.sourceEnd;
42	}	42	}
43		43	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
44	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,	44	FlowInfo flowInfo, boolean valueRequired) {
45	FlowInfo flowInfo) {
46	int initialComplaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;	45	int initialComplaintLevel = (flowInfo.reachMode() & FlowInfo.UNREACHABLE) != 0 ? Statement.COMPLAINED_FAKE_REACHABLE : Statement.NOT_COMPLAINED;
47	Constant cst = this.condition.optimizedBooleanConstant();	46	Constant cst = this.condition.optimizedBooleanConstant();
48	boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;	47	boolean isConditionOptimizedTrue = cst != Constant.NotAConstant && cst.booleanValue() == true;
49	boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;	48	boolean isConditionOptimizedFalse = cst != Constant.NotAConstant && cst.booleanValue() == false;
50		49
51	int mode = flowInfo.reachMode();	50	int mode = flowInfo.reachMode();
52	flowInfo = this.condition.analyseCode(currentScope, flowContext, flowInfo, cst == Constant.NotAConstant);	51	flowInfo = this.condition.analyseCode(currentScope, flowContext, flowInfo, valueRequired && (cst == Constant.NotAConstant));
53		52
54	// process the if-true part	53	// process the if-true part
55	FlowInfo trueFlowInfo = flowInfo.initsWhenTrue().copy();	54	FlowInfo trueFlowInfo = flowInfo.initsWhenTrue().copy();
Lines 62-68 Link Here
62	}	61	}
63	}	62	}
64	this.trueInitStateIndex = currentScope.methodScope().recordInitializationStates(trueFlowInfo);	63	this.trueInitStateIndex = currentScope.methodScope().recordInitializationStates(trueFlowInfo);
65	trueFlowInfo = this.valueIfTrue.analyseCode(currentScope, flowContext, trueFlowInfo);	64	trueFlowInfo = this.valueIfTrue.analyseCode(currentScope, flowContext, trueFlowInfo, valueRequired);
66		65
67	// process the if-false part	66	// process the if-false part
68	FlowInfo falseFlowInfo = flowInfo.initsWhenFalse().copy();	67	FlowInfo falseFlowInfo = flowInfo.initsWhenFalse().copy();
Lines 75-81 Link Here
75	}	74	}
76	}	75	}
77	this.falseInitStateIndex = currentScope.methodScope().recordInitializationStates(falseFlowInfo);	76	this.falseInitStateIndex = currentScope.methodScope().recordInitializationStates(falseFlowInfo);
78	falseFlowInfo = this.valueIfFalse.analyseCode(currentScope, flowContext, falseFlowInfo);	77	falseFlowInfo = this.valueIfFalse.analyseCode(currentScope, flowContext, falseFlowInfo, valueRequired);
79		78
80	// merge if-true & if-false initializations	79	// merge if-true & if-false initializations
81	FlowInfo mergedInfo;	80	FlowInfo mergedInfo;

Lines 38-44 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/DoStatement.java (-4 / +12 lines)
38	if (action instanceof EmptyStatement) action.bits \|= ASTNode.IsUsefulEmptyStatement;	38	if (action instanceof EmptyStatement) action.bits \|= ASTNode.IsUsefulEmptyStatement;
39	}	39	}
40		40
41	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	41	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		42
42	this.breakLabel = new BranchLabel();	43	this.breakLabel = new BranchLabel();
43	this.continueLabel = new BranchLabel();	44	this.continueLabel = new BranchLabel();
44	LoopingFlowContext loopingContext =	45	LoopingFlowContext loopingContext =
Lines 66-72 Link Here
66	// or catch blocks	67	// or catch blocks
67	if ((this.action != null) && !this.action.isEmptyBlock()) {	68	if ((this.action != null) && !this.action.isEmptyBlock()) {
68	actionInfo = this.action.	69	actionInfo = this.action.
69	analyseCode(currentScope, loopingContext, actionInfo).	70	analyseCode(currentScope, loopingContext, actionInfo, false). // statements, values are ignored
70	unconditionalInits();	71	unconditionalInits();
71		72
72	// code generation can be optimized when no need to continue in the loop	73	// code generation can be optimized when no need to continue in the loop
Lines 100-106 Link Here
100	null, currentScope)),	101	null, currentScope)),
101	(this.action == null	102	(this.action == null
102	? actionInfo	103	? actionInfo
103	: (actionInfo.mergedWith(loopingContext.initsOnContinue))).copy());	104	: (actionInfo.mergedWith(loopingContext.initsOnContinue))).copy(),
		105	!isConditionOptimizedFalse); // subject to optimization if constant false
104	this.preConditionInitStateIndex = currentScope.methodScope().recordInitializationStates(actionInfo);	106	this.preConditionInitStateIndex = currentScope.methodScope().recordInitializationStates(actionInfo);
105	if (!isConditionOptimizedFalse && this.continueLabel != null) {	107	if (!isConditionOptimizedFalse && this.continueLabel != null) {
106	loopingContext.complainOnDeferredFinalChecks(currentScope, condInfo);	108	loopingContext.complainOnDeferredFinalChecks(currentScope, condInfo);
Lines 206-212 Link Here
206	}	208	}
207		209
208	public void resolve(BlockScope scope) {	210	public void resolve(BlockScope scope) {
209	TypeBinding type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);	211	TypeBinding type = null;
		212	try {
		213	scope.isInsideCondition = true;
		214	type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);
		215	} finally {
		216	scope.isInsideCondition = false;
		217	}
210	this.condition.computeConversion(scope, type, type);	218	this.condition.computeConversion(scope, type, type);
211	if (this.action != null)	219	if (this.action != null)
212	this.action.resolve(scope);	220	this.action.resolve(scope);

Lines 69-123 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java (-13 / +17 lines)
69	// does not preclude the variable from being null in an enclosing scope	69	// does not preclude the variable from being null in an enclosing scope
70	}	70	}
71		71
72	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	72	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired)
		73	{
73	FlowInfo result;	74	FlowInfo result;
74	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	75	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
75	if ((this.left.constant != Constant.NotAConstant) && (this.left.constant.typeID() == T_boolean)) {	76	if ((this.left.constant != Constant.NotAConstant) && (this.left.constant.typeID() == T_boolean)) {
76	if (this.left.constant.booleanValue()) { // true == anything	77	if (this.left.constant.booleanValue()) { // true == anything
77	// this is equivalent to the right argument inits	78	// this is equivalent to the right argument inits
78	result = this.right.analyseCode(currentScope, flowContext, flowInfo);	79	result = this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
79	} else { // false == anything	80	} else { // false == anything
80	// this is equivalent to the right argument inits negated	81	// this is equivalent to the right argument inits negated
81	result = this.right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();	82	result = this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired).asNegatedCondition();
82	}	83	}
83	}	84	}
84	else if ((this.right.constant != Constant.NotAConstant) && (this.right.constant.typeID() == T_boolean)) {	85	else if ((this.right.constant != Constant.NotAConstant) && (this.right.constant.typeID() == T_boolean)) {
85	if (this.right.constant.booleanValue()) { // anything == true	86	if (this.right.constant.booleanValue()) { // anything == true
86	// this is equivalent to the left argument inits	87	// this is equivalent to the left argument inits
87	result = this.left.analyseCode(currentScope, flowContext, flowInfo);	88	result = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
88	} else { // anything == false	89	} else { // anything == false
89	// this is equivalent to the right argument inits negated	90	// this is equivalent to the right argument inits negated
90	result = this.left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();	91	result = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).asNegatedCondition();
91	}	92	}
92	}	93	}
93	else {	94	else {
94	result = this.right.analyseCode(	95	result = this.right.analyseCode(
95	currentScope, flowContext,	96	currentScope, flowContext,
96	this.left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).unconditionalInits();	97	this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits(),
		98	valueRequired).
		99	unconditionalInits();
97	}	100	}
98	} else { //NOT_EQUAL :	101	} else { //NOT_EQUAL :
99	if ((this.left.constant != Constant.NotAConstant) && (this.left.constant.typeID() == T_boolean)) {	102	if ((this.left.constant != Constant.NotAConstant) && (this.left.constant.typeID() == T_boolean)) {
100	if (!this.left.constant.booleanValue()) { // false != anything	103	if (!this.left.constant.booleanValue()) { // false != anything
101	// this is equivalent to the right argument inits	104	// this is equivalent to the right argument inits
102	result = this.right.analyseCode(currentScope, flowContext, flowInfo);	105	result = this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
103	} else { // true != anything	106	} else { // true != anything
104	// this is equivalent to the right argument inits negated	107	// this is equivalent to the right argument inits negated
105	result = this.right.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();	108	result = this.right.analyseCode(currentScope, flowContext, flowInfo, valueRequired).asNegatedCondition();
106	}	109	}
107	}	110	}
108	else if ((this.right.constant != Constant.NotAConstant) && (this.right.constant.typeID() == T_boolean)) {	111	else if ((this.right.constant != Constant.NotAConstant) && (this.right.constant.typeID() == T_boolean)) {
109	if (!this.right.constant.booleanValue()) { // anything != false	112	if (!this.right.constant.booleanValue()) { // anything != false
110	// this is equivalent to the right argument inits	113	// this is equivalent to the right argument inits
111	result = this.left.analyseCode(currentScope, flowContext, flowInfo);	114	result = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired);
112	} else { // anything != true	115	} else { // anything != true
113	// this is equivalent to the right argument inits negated	116	// this is equivalent to the right argument inits negated
114	result = this.left.analyseCode(currentScope, flowContext, flowInfo).asNegatedCondition();	117	result = this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).asNegatedCondition();
115	}	118	}
116	}	119	}
117	else {	120	else {
118	result = this.right.analyseCode(	121	result = this.right.analyseCode(
119	currentScope, flowContext,	122	currentScope, flowContext,
120	this.left.analyseCode(currentScope, flowContext, flowInfo).unconditionalInits()).	123	this.left.analyseCode(currentScope, flowContext, flowInfo, valueRequired).unconditionalInits(),
		124	valueRequired).
121	/* unneeded since we flatten it: asNegatedCondition(). */	125	/* unneeded since we flatten it: asNegatedCondition(). */
122	unconditionalInits();	126	unconditionalInits();
123	}	127	}

Lines 72-78 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ForeachStatement.java (-4 / +4 lines)
72	this.kind = -1;	72	this.kind = -1;
73	}	73	}
74		74
75	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	75	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
76	// initialize break and continue labels	76	// initialize break and continue labels
77	this.breakLabel = new BranchLabel();	77	this.breakLabel = new BranchLabel();
78	this.continueLabel = new BranchLabel();	78	this.continueLabel = new BranchLabel();
Lines 80-87 Link Here
80		80
81	// process the element variable and collection	81	// process the element variable and collection
82	this.collection.checkNPE(currentScope, flowContext, flowInfo);	82	this.collection.checkNPE(currentScope, flowContext, flowInfo);
83	flowInfo = this.elementVariable.analyseCode(this.scope, flowContext, flowInfo);	83	flowInfo = this.elementVariable.analyseCode(this.scope, flowContext, flowInfo, false); // analyse as a statement -> ignore value
84	FlowInfo condInfo = this.collection.analyseCode(this.scope, flowContext, flowInfo.copy());	84	FlowInfo condInfo = this.collection.analyseCode(this.scope, flowContext, flowInfo.copy(), true); // collection value is required
85		85
86	// element variable will be assigned when iterating	86	// element variable will be assigned when iterating
87	condInfo.markAsDefinitelyAssigned(this.elementVariable.binding);	87	condInfo.markAsDefinitelyAssigned(this.elementVariable.binding);
Lines 100-106 Link Here
100	&& currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3))) {	100	&& currentScope.compilerOptions().complianceLevel <= ClassFileConstants.JDK1_3))) {
101		101
102	if (this.action.complainIfUnreachable(actionInfo, this.scope, initialComplaintLevel) < Statement.COMPLAINED_UNREACHABLE) {	102	if (this.action.complainIfUnreachable(actionInfo, this.scope, initialComplaintLevel) < Statement.COMPLAINED_UNREACHABLE) {
103	actionInfo = this.action.analyseCode(this.scope, loopingContext, actionInfo).unconditionalCopy();	103	actionInfo = this.action.analyseCode(this.scope, loopingContext, actionInfo, false).unconditionalCopy(); // statement values are ignored
104	}	104	}
105		105
106	// code generation can be optimized when no need to continue in the loop	106	// code generation can be optimized when no need to continue in the loop

Lines 33-45 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Initializer.java (-5 / +2 lines)
33	}	33	}
34	}	34	}
35		35
36	public FlowInfo analyseCode(	36	public FlowInfo analyseCode(MethodScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
37	MethodScope currentScope,
38	FlowContext flowContext,
39	FlowInfo flowInfo) {
40		37
41	if (this.block != null) {	38	if (this.block != null) {
42	return this.block.analyseCode(currentScope, flowContext, flowInfo);	39	return this.block.analyseCode(currentScope, flowContext, flowInfo, false); // statements, ignore value
43	}	40	}
44	return flowInfo;	41	return flowInfo;
45	}	42	}

Lines 30-39 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/InstanceOfExpression.java (-3 / +3 lines)
30	this.sourceEnd = type.sourceEnd;	30	this.sourceEnd = type.sourceEnd;
31	}	31	}
32		32
33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
34	LocalVariableBinding local = this.expression.localVariableBinding();	34	LocalVariableBinding local = this.expression.localVariableBinding();
35	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	35	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
36	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo).	36	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo, valueRequired).
37	unconditionalInits();	37	unconditionalInits();
38	FlowInfo initsWhenTrue = flowInfo.copy();	38	FlowInfo initsWhenTrue = flowInfo.copy();
39	initsWhenTrue.markAsComparedEqualToNonNull(local);	39	initsWhenTrue.markAsComparedEqualToNonNull(local);
Lines 45-51 Link Here
45	// no impact upon enclosing try context	45	// no impact upon enclosing try context
46	return FlowInfo.conditional(initsWhenTrue, flowInfo.copy());	46	return FlowInfo.conditional(initsWhenTrue, flowInfo.copy());
47	}	47	}
48	return this.expression.analyseCode(currentScope, flowContext, flowInfo).	48	return this.expression.analyseCode(currentScope, flowContext, flowInfo, valueRequired).
49	unconditionalInits();	49	unconditionalInits();
50	}	50	}
51		51

Lines 10-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Literal.java (-10 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	11	package org.eclipse.jdt.internal.compiler.ast;
12		12
13	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
14	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
15	import org.eclipse.jdt.internal.compiler.impl.*;	13	import org.eclipse.jdt.internal.compiler.impl.*;
16	import org.eclipse.jdt.internal.compiler.lookup.*;	14	import org.eclipse.jdt.internal.compiler.lookup.*;
17		15
Lines 23-36 Link Here
23	this.sourceEnd = e;	21	this.sourceEnd = e;
24	}	22	}
25		23
26	public FlowInfo analyseCode(
27	BlockScope currentScope,
28	FlowContext flowContext,
29	FlowInfo flowInfo) {
30
31	return flowInfo;
32	}
33
34	public abstract void computeConstant();	24	public abstract void computeConstant();
35		25
36	public abstract TypeBinding literalType(BlockScope scope);	26	public abstract TypeBinding literalType(BlockScope scope);

Lines 34-68 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-27 / +27 lines)
34	this.declarationEnd = sourceEnd;	34	this.declarationEnd = sourceEnd;
35	}	35	}
36		36
37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
38	// record variable initialization if any	38	// record variable initialization if any
39	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {	39	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
40	this.bits \|= ASTNode.IsLocalDeclarationReachable; // only set if actually reached	40	this.bits \|= ASTNode.IsLocalDeclarationReachable; // only set if actually reached
41	}	41	}
42	if (this.initialization == null) {	42	if (this.initialization == null) {
		43	return flowInfo;
		44	}
		45	if ((this.initialization.implicitConversion & TypeIds.UNBOXING) != 0) {
		46	this.initialization.checkNPE(currentScope, flowContext, flowInfo);
		47	}
		48	int nullStatus = this.initialization.nullStatus(flowInfo);
		49	flowInfo =
		50	this.initialization
		51	.analyseCode(currentScope, flowContext, flowInfo, true) // at this point we must assume that the local is used, thus the side effect requires the value
		52	.unconditionalInits();
		53	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes
		54	this.bits \|= FirstAssignmentToLocal;
		55	} else {
		56	this.bits &= ~FirstAssignmentToLocal; // int i = (i = 0);
		57	}
		58	flowInfo.markAsDefinitelyAssigned(this.binding);
		59	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {
		60	flowInfo.markNullStatus(this.binding, nullStatus);
		61	// no need to inform enclosing try block since its locals won't get
		62	// known by the finally block
		63	}
43	return flowInfo;	64	return flowInfo;
44	}	65	}
45	if ((this.initialization.implicitConversion & TypeIds.UNBOXING) != 0) {
46	this.initialization.checkNPE(currentScope, flowContext, flowInfo);
47	}
48	int nullStatus = this.initialization.nullStatus(flowInfo);
49	flowInfo =
50	this.initialization
51	.analyseCode(currentScope, flowContext, flowInfo)
52	.unconditionalInits();
53	if (!flowInfo.isDefinitelyAssigned(this.binding)){// for local variable debug attributes
54	this.bits \|= FirstAssignmentToLocal;
55	} else {
56	this.bits &= ~FirstAssignmentToLocal; // int i = (i = 0);
57	}
58	flowInfo.markAsDefinitelyAssigned(this.binding);
59	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {
60	flowInfo.markNullStatus(this.binding, nullStatus);
61	// no need to inform enclosing try block since its locals won't get
62	// known by the finally block
63	}
64	return flowInfo;
65	}
66		66
67	public void checkModifiers() {	67	public void checkModifiers() {
68		68

Lines 54-63 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (-4 / +6 lines)
54	anonymousType.allocation = this;	54	anonymousType.allocation = this;
55	}	55	}
56		56
57	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	57	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		58	// constructor may have side effect => thus require values from all child nodes
		59
58	// analyse the enclosing instance	60	// analyse the enclosing instance
59	if (this.enclosingInstance != null) {	61	if (this.enclosingInstance != null) {
60	flowInfo = this.enclosingInstance.analyseCode(currentScope, flowContext, flowInfo);	62	flowInfo = this.enclosingInstance.analyseCode(currentScope, flowContext, flowInfo, true);
61	}	63	}
62		64
63	// check captured variables are initialized in current context (26134)	65	// check captured variables are initialized in current context (26134)
Lines 71-77 Link Here
71	// process arguments	73	// process arguments
72	if (this.arguments != null) {	74	if (this.arguments != null) {
73	for (int i = 0, count = this.arguments.length; i < count; i++) {	75	for (int i = 0, count = this.arguments.length; i < count; i++) {
74	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo);	76	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo, true);
75	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {	77	if ((this.arguments[i].implicitConversion & TypeIds.UNBOXING) != 0) {
76	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	78	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
77	}	79	}
Lines 80-86 Link Here
80		82
81	// analyse the anonymous nested type	83	// analyse the anonymous nested type
82	if (this.anonymousType != null) {	84	if (this.anonymousType != null) {
83	flowInfo = this.anonymousType.analyseCode(currentScope, flowContext, flowInfo);	85	flowInfo = this.anonymousType.analyseCode(currentScope, flowContext, flowInfo, false); // not a value
84	}	86	}
85		87
86	// record some dependency information for exception types	88	// record some dependency information for exception types

Lines 30-42 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (-2 / +2 lines)
30	this.expression = expression ;	30	this.expression = expression ;
31	}	31	}
32		32
33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) { // here requires to generate a sequence of finally blocks invocations depending corresponding	33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) { // here requires to generate a sequence of finally blocks invocations depending corresponding
34	// to each of the traversed try statements, so that execution will terminate properly.	34	// to each of the traversed try statements, so that execution will terminate properly.
35		35
36	// lookup the label, this should answer the returnContext	36	// lookup the label, this should answer the returnContext
37		37
38	if (this.expression != null) {	38	if (this.expression != null) {
39	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo);	39	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo, true);
40	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	40	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
41	this.expression.checkNPE(currentScope, flowContext, flowInfo);	41	this.expression.checkNPE(currentScope, flowContext, flowInfo);
42	}	42	}

Lines 61-68 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java (-14 / +9 lines)
61	int naturalExitMergeInitStateIndex = -1;	61	int naturalExitMergeInitStateIndex = -1;
62	int[] catchExitInitStateIndexes;	62	int[] catchExitInitStateIndexes;
63		63
64	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
65		64
		65	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, boolean valueRequired) {
		66	//
		67
66	// Consider the try block and catch block so as to compute the intersection of initializations and	68	// Consider the try block and catch block so as to compute the intersection of initializations and
67	// the minimum exit relative depth amongst all of them. Then consider the subroutine, and append its	69	// the minimum exit relative depth amongst all of them. Then consider the subroutine, and append its
68	// initialization to the try/catch ones, if the subroutine completes normally. If the subroutine does not	70	// initialization to the try/catch ones, if the subroutine completes normally. If the subroutine does not
Lines 99-105 Link Here
99	if (this.tryBlock.isEmptyBlock()) {	101	if (this.tryBlock.isEmptyBlock()) {
100	tryInfo = flowInfo;	102	tryInfo = flowInfo;
101	} else {	103	} else {
102	tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());	104	tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy(), false); // statements, ignore values
103	if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)	105	if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
104	this.bits \|= ASTNode.IsTryBlockExiting;	106	this.bits \|= ASTNode.IsTryBlockExiting;
105	}	107	}
Lines 151-161 Link Here
151	if (this.tryBlock.statements == null) {	153	if (this.tryBlock.statements == null) {
152	catchInfo.setReachMode(FlowInfo.UNREACHABLE);	154	catchInfo.setReachMode(FlowInfo.UNREACHABLE);
153	}	155	}
154	catchInfo =	156	catchInfo = this.catchBlocks[i].analyseCode(currentScope, flowContext, catchInfo, false); // statements, ignore values
155	this.catchBlocks[i].analyseCode(
156	currentScope,
157	flowContext,
158	catchInfo);
159	this.catchExitInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(catchInfo);	157	this.catchExitInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(catchInfo);
160	this.catchExits[i] =	158	this.catchExits[i] =
161	(catchInfo.tagBits & FlowInfo.UNREACHABLE) != 0;	159	(catchInfo.tagBits & FlowInfo.UNREACHABLE) != 0;
Lines 183-189 Link Here
183	.analyseCode(	181	.analyseCode(
184	currentScope,	182	currentScope,
185	finallyContext = new FinallyFlowContext(flowContext, this.finallyBlock),	183	finallyContext = new FinallyFlowContext(flowContext, this.finallyBlock),
186	flowInfo.nullInfoLessUnconditionalCopy())	184	flowInfo.nullInfoLessUnconditionalCopy(),
		185	false) // statements, ignore values
187	.unconditionalInits();	186	.unconditionalInits();
188	if (subInfo == FlowInfo.DEAD_END) {	187	if (subInfo == FlowInfo.DEAD_END) {
189	this.bits \|= ASTNode.IsSubRoutineEscaping;	188	this.bits \|= ASTNode.IsSubRoutineEscaping;
Lines 208-214 Link Here
208	if (this.tryBlock.isEmptyBlock()) {	207	if (this.tryBlock.isEmptyBlock()) {
209	tryInfo = flowInfo;	208	tryInfo = flowInfo;
210	} else {	209	} else {
211	tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy());	210	tryInfo = this.tryBlock.analyseCode(currentScope, handlingContext, flowInfo.copy(), false); // statements, ignore values
212	if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)	211	if ((tryInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
213	this.bits \|= ASTNode.IsTryBlockExiting;	212	this.bits \|= ASTNode.IsTryBlockExiting;
214	}	213	}
Lines 260-270 Link Here
260	if (this.tryBlock.statements == null) {	259	if (this.tryBlock.statements == null) {
261	catchInfo.setReachMode(FlowInfo.UNREACHABLE);	260	catchInfo.setReachMode(FlowInfo.UNREACHABLE);
262	}	261	}
263	catchInfo =	262	catchInfo = this.catchBlocks[i].analyseCode(currentScope, insideSubContext, catchInfo, false); // statements, ignore values
264	this.catchBlocks[i].analyseCode(
265	currentScope,
266	insideSubContext,
267	catchInfo);
268	this.catchExitInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(catchInfo);	263	this.catchExitInitStateIndexes[i] = currentScope.methodScope().recordInitializationStates(catchInfo);
269	this.catchExits[i] =	264	this.catchExits[i] =
270	(catchInfo.tagBits & FlowInfo.UNREACHABLE) != 0;	265	(catchInfo.tagBits & FlowInfo.UNREACHABLE) != 0;

Lines 26-46 Link Here

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

Lines 38-44 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/ForeachStatementTest.java (-2 / +24 lines)
38	// Static initializer to specify tests subset using TESTS_* static variables	38	// Static initializer to specify tests subset using TESTS_* static variables
39	// All specified tests which do not belong to the class are skipped...	39	// All specified tests which do not belong to the class are skipped...
40	static {	40	static {
41	// TESTS_NAMES = new String[] { "test000" };	41	// TESTS_NAMES = new String[] { "test026" };
42	// TESTS_NUMBERS = new int[] { 50, 51, 52, 53 };	42	// TESTS_NUMBERS = new int[] { 50, 51, 52, 53 };
43	// TESTS_RANGE = new int[] { 34, 38 };	43	// TESTS_RANGE = new int[] { 34, 38 };
44	}	44	}
Lines 1245-1251 Link Here
1245	" void test() {\n" +	1245	" void test() {\n" +
1246	" for (Object object : array) {\n" +	1246	" for (Object object : array) {\n" +
1247	" String str = object.toString();\n" +	1247	" String str = object.toString();\n" +
1248	" str += \"\";\n" + // force 'str' to be preserved during codegen	1248	" str += \"\";\n" + // try force 'str' to be preserved during codegen (can still be optimized out)
		1249	" }\n" +
		1250	" }\n" +
		1251	" public static void main(String[] args) {\n" +
		1252	" new X().test();\n" +
		1253	" System.out.println(\"SUCCESS\");\n" +
		1254	" }\n" +
		1255	"}\n",
		1256	},
		1257	"SUCCESS");
		1258	}
		1259	// 68440 - verify error due to local variable invalid slot sharing
		1260	public void test026a() {
		1261	this.runConformTest(
		1262	new String[] {
		1263	"X.java",
		1264	"public class X {\n" +
		1265	" Object[] array = {\n" +
		1266	" };\n" +
		1267	" void test() {\n" +
		1268	" for (Object object : array) {\n" +
		1269	" String str = object.toString();\n" +
		1270	" System.out.print(str);\n" + // really force 'str' to be preserved during codegen
1249	" }\n" +	1271	" }\n" +
1250	" }\n" +	1272	" }\n" +
1251	" public static void main(String[] args) {\n" +	1273	" public static void main(String[] args) {\n" +