Attachment #183877 for bug #328830

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 197-202 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java (+3 lines)
197	abort = true;	197	abort = true;
198	}	198	}
199	} else if (e.compilationResult == CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE) {	199	} else if (e.compilationResult == CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE) {
		200	if (e.getScope() != this.scope) {
		201	throw e;
		202	}
200	classFile.contentsOffset = problemResetPC;	203	classFile.contentsOffset = problemResetPC;
201	classFile.methodCount--;	204	classFile.methodCount--;
202	classFile.codeStream.resetForCodeGenUnusedLocals();	205	classFile.codeStream.resetForCodeGenUnusedLocals();

Lines 75-81 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-1 / +3 lines)
75	for (int i = 0, count = syntheticArguments.length; i < count; i++){	75	for (int i = 0, count = syntheticArguments.length; i < count; i++){
76	SyntheticArgumentBinding syntheticArgument = syntheticArguments[i];	76	SyntheticArgumentBinding syntheticArgument = syntheticArguments[i];
77	LocalVariableBinding targetLocal;	77	LocalVariableBinding targetLocal;
78	if ((targetLocal = syntheticArgument.actualOuterLocalVariable) == null) continue;	78	if ((targetLocal = syntheticArgument.actualOuterLocalVariable) == null) {
		79	continue;
		80	}
79	if (targetLocal.declaration != null && !flowInfo.isDefinitelyAssigned(targetLocal)){	81	if (targetLocal.declaration != null && !flowInfo.isDefinitelyAssigned(targetLocal)){
80	currentScope.problemReporter().uninitializedLocalVariable(targetLocal, this);	82	currentScope.problemReporter().uninitializedLocalVariable(targetLocal, this);
81	}	83	}

Lines 149-157 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Clinit.java (-3 / +3 lines)
149	* @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile	149	* @param classFile org.eclipse.jdt.internal.compiler.codegen.ClassFile
150	*/	150	*/
151	private void generateCode(	151	private void generateCode(
152	ClassScope classScope,	152	ClassScope classScope,
153	ClassFile classFile,	153	ClassFile classFile,
154	int clinitOffset) {	154	int clinitOffset) {
155		155
156	ConstantPool constantPool = classFile.constantPool;	156	ConstantPool constantPool = classFile.constantPool;
157	int constantPoolOffset = constantPool.currentOffset;	157	int constantPoolOffset = constantPool.currentOffset;

Lines 229-234 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java (-3 / +8 lines)
229	abort = true;	229	abort = true;
230	}	230	}
231	} else if (e.compilationResult == CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE) {	231	} else if (e.compilationResult == CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE) {
		232	if (e.getScope() != this.scope) {
		233	throw e;
		234	}
232	classFile.contentsOffset = problemResetPC;	235	classFile.contentsOffset = problemResetPC;
233	classFile.methodCount--;	236	classFile.methodCount--;
234	classFile.codeStream.resetForCodeGenUnusedLocals();	237	classFile.codeStream.resetForCodeGenUnusedLocals();
Lines 266-272 Link Here
266	syntheticArgs = nestedType.syntheticOuterLocalVariables();	269	syntheticArgs = nestedType.syntheticOuterLocalVariables();
267	for (int i = 0, max = syntheticArgs == null ? 0 : syntheticArgs.length; i < max; i++) {	270	for (int i = 0, max = syntheticArgs == null ? 0 : syntheticArgs.length; i < max; i++) {
268	SyntheticArgumentBinding syntheticArg;	271	SyntheticArgumentBinding syntheticArg;
269	if ((syntheticArg = syntheticArgs[i]).matchingField != null) {	272	if ((syntheticArg = syntheticArgs[i]).matchingField != null
		273	&& syntheticArg.actualOuterLocalVariable.resolvedPosition != -1) {
270	codeStream.aload_0();	274	codeStream.aload_0();
271	codeStream.load(syntheticArg);	275	codeStream.load(syntheticArg);
272	codeStream.fieldAccess(Opcodes.OPC_putfield, syntheticArg.matchingField, null /* default declaringClass */);	276	codeStream.fieldAccess(Opcodes.OPC_putfield, syntheticArg.matchingField, null /* default declaringClass */);
Lines 294-303 Link Here
294		298
295	if (declaringClass.isNestedType()){	299	if (declaringClass.isNestedType()){
296	this.scope.extraSyntheticArguments = declaringClass.syntheticOuterLocalVariables();	300	this.scope.extraSyntheticArguments = declaringClass.syntheticOuterLocalVariables();
		301	int enclosingInstancesSlotSize = declaringClass.getEnclosingInstancesSlotSize();
297	this.scope.computeLocalVariablePositions(// consider synthetic arguments if any	302	this.scope.computeLocalVariablePositions(// consider synthetic arguments if any
298	declaringClass.getEnclosingInstancesSlotSize() + 1 + enumOffset,	303	enclosingInstancesSlotSize + 1 + enumOffset,
299	codeStream);	304	codeStream);
300	argSlotSize += declaringClass.getEnclosingInstancesSlotSize();	305	argSlotSize += enclosingInstancesSlotSize;
301	argSlotSize += declaringClass.getOuterLocalVariablesSlotSize();	306	argSlotSize += declaringClass.getOuterLocalVariablesSlotSize();
302	} else {	307	} else {
303	this.scope.computeLocalVariablePositions(1 + enumOffset, codeStream);	308	this.scope.computeLocalVariablePositions(1 + enumOffset, codeStream);

Lines 192-197 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java (+4 lines)
192	codeStream.recordPositionsFrom(pc, this.sourceStart);	192	codeStream.recordPositionsFrom(pc, this.sourceStart);
193	return;	193	return;
194	}	194	}
		195	reportOnlyUselesslyReadPrivateField(currentScope, this.binding, valueRequired);
195	FieldBinding codegenBinding = this.binding.original();	196	FieldBinding codegenBinding = this.binding.original();
196	boolean isStatic = codegenBinding.isStatic();	197	boolean isStatic = codegenBinding.isStatic();
197	boolean isThisReceiver = this.receiver instanceof ThisReference;	198	boolean isThisReceiver = this.receiver instanceof ThisReference;
Lines 523-528 Link Here
523	// constants are propaged when the field is final	524	// constants are propaged when the field is final
524	// and initialized with a (compile time) constant	525	// and initialized with a (compile time) constant
525		526
		527	if (scope.isInsideCondition)
		528	this.bits \|= ASTNode.IsInsideCondition;
		529
526	//always ignore receiver cast, since may affect constant pool reference	530	//always ignore receiver cast, since may affect constant pool reference
527	boolean receiverCast = false;	531	boolean receiverCast = false;
528	if (this.receiver instanceof CastExpression) {	532	if (this.receiver instanceof CastExpression) {

Lines 377-383 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ForStatement.java (-1 / +7 lines)
377	for (int i = 0, length = this.initializations.length; i < length; i++)	377	for (int i = 0, length = this.initializations.length; i < length; i++)
378	this.initializations[i].resolve(this.scope);	378	this.initializations[i].resolve(this.scope);
379	if (this.condition != null) {	379	if (this.condition != null) {
380	TypeBinding type = this.condition.resolveTypeExpecting(this.scope, TypeBinding.BOOLEAN);	380	TypeBinding type = null;
		381	try {
		382	upperScope.isInsideCondition = true;
		383	type = this.condition.resolveTypeExpecting(this.scope, TypeBinding.BOOLEAN);
		384	} finally {
		385	upperScope.isInsideCondition = false;
		386	}
381	this.condition.computeConversion(this.scope, type, type);	387	this.condition.computeConversion(this.scope, type, type);
382	}	388	}
383	if (this.increments != null)	389	if (this.increments != null)

Lines 260-266 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/IfStatement.java (-1 / +7 lines)
260	}	260	}
261		261
262	public void resolve(BlockScope scope) {	262	public void resolve(BlockScope scope) {
263	TypeBinding type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);	263	TypeBinding type = null;
		264	try {
		265	scope.isInsideCondition = true;
		266	type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);
		267	} finally {
		268	scope.isInsideCondition = false;
		269	}
264	this.condition.computeConversion(scope, type, type);	270	this.condition.computeConversion(scope, type, type);
265	if (this.thenStatement != null)	271	if (this.thenStatement != null)
266	this.thenStatement.resolve(scope);	272	this.thenStatement.resolve(scope);

Lines 32-37 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (-2 / +14 lines)
32	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	32	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
33	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;	33	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
34	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	34	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
		35	import org.eclipse.jdt.internal.compiler.problem.AbortMethod;
35		36
36	/**	37	/**
37	* Variation on allocation, where can optionally be specified any of:	38	* Variation on allocation, where can optionally be specified any of:
Lines 126-131 Link Here
126	codeStream.ldc(String.valueOf(this.enumConstant.name));	127	codeStream.ldc(String.valueOf(this.enumConstant.name));
127	codeStream.generateInlinedValue(this.enumConstant.binding.id);	128	codeStream.generateInlinedValue(this.enumConstant.binding.id);
128	}	129	}
		130	// invoke constructor
		131	int constantPoolOffset = codeStream.constantPool.currentOffset;
		132	int constantPoolIndex = codeStream.constantPool.currentIndex;
129	// handling innerclass instance allocation - enclosing instance arguments	133	// handling innerclass instance allocation - enclosing instance arguments
130	if (allocatedType.isNestedType()) {	134	if (allocatedType.isNestedType()) {
131	codeStream.generateSyntheticEnclosingInstanceValues(	135	codeStream.generateSyntheticEnclosingInstanceValues(
Lines 144-150 Link Here
144	this);	148	this);
145	}	149	}
146		150
147	// invoke constructor
148	if (this.syntheticAccessor == null) {	151	if (this.syntheticAccessor == null) {
149	codeStream.invoke(Opcodes.OPC_invokespecial, codegenBinding, null /* default declaringClass */);	152	codeStream.invoke(Opcodes.OPC_invokespecial, codegenBinding, null /* default declaringClass */);
150	} else {	153	} else {
Lines 174-180 Link Here
174	codeStream.recordPositionsFrom(pc, this.sourceStart);	177	codeStream.recordPositionsFrom(pc, this.sourceStart);
175		178
176	if (this.anonymousType != null) {	179	if (this.anonymousType != null) {
177	this.anonymousType.generateCode(currentScope, codeStream);	180	try {
		181	this.anonymousType.generateCode(currentScope, codeStream);
		182	} catch(AbortMethod e) {
		183	if (e.compilationResult == CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE) {
		184	this.binding.resetSignature();
		185	codeStream.constantPool.currentIndex = constantPoolIndex;
		186	codeStream.constantPool.currentOffset = constantPoolOffset;
		187	}
		188	throw e;
		189	}
178	}	190	}
179	}	191	}
180		192




	} else {
		FieldBinding lastFieldBinding = generateReadSequence(currentScope, codeStream);
		if (lastFieldBinding != null) {
			reportOnlyUselesslyReadPrivateField(currentScope, lastFieldBinding, valueRequired);
			boolean isStatic = lastFieldBinding.isStatic();
			Constant fieldConstant = lastFieldBinding.constant();
			if (fieldConstant != Constant.NotAConstant) {

				// local was tagged as uninitialized
				return;
			}
			currentScope.emulateOuterAccess(localVariableBinding);
				case LocalVariableBinding.FAKE_USED :
				case LocalVariableBinding.USED :
					currentScope.emulateOuterAccess(localVariableBinding);
			}
		}
	}
}

	// field and/or local are done before type lookups
	// the only available value for the restrictiveFlag BEFORE
	// the TC is Flag_Type Flag_LocalField and Flag_TypeLocalField

	if (scope.isInsideCondition)
		this.bits |= ASTNode.IsInsideCondition;

	this.actualReceiverType = scope.enclosingReceiverType();
	this.constant = Constant.NotAConstant;
	if ((this.binding = scope.getBinding(this.tokens, this.bits & ASTNode.RestrictiveFlagMASK, this, true /*resolve*/)).isValidBinding()) {

Lines 171-177 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java (-9 / +18 lines)
171	currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);	171	currentScope.problemReporter().uninitializedLocalVariable(localBinding, this);
172	}	172	}
173	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {	173	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0) {
174	localBinding.useFlag = LocalVariableBinding.USED;	174	// check possibility for optimization (https://bugs.eclipse.org/328830):
		175	if ((this.implicitConversion & TypeIds.UNBOXING) == 0 // only optimize if no unboxing is involved
		176	&& (this.bits & ASTNode.IsInsideCondition) != 0) // only optimize within a condition that may be unnecessary
		177	{
		178	// use values < 0 to count the number of uses which might fall subject to optimization:
		179	if (localBinding.useFlag <= LocalVariableBinding.UNUSED)
		180	localBinding.useFlag--;
		181	} else {
		182	localBinding.useFlag = LocalVariableBinding.USED;
		183	}
175	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {	184	} else if (localBinding.useFlag == LocalVariableBinding.UNUSED) {
176	localBinding.useFlag = LocalVariableBinding.FAKE_USED;	185	localBinding.useFlag = LocalVariableBinding.FAKE_USED;
177	}	186	}
Lines 370-375 Link Here
370	switch (this.bits & ASTNode.RestrictiveFlagMASK) {	379	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
371	case Binding.FIELD : // reading a field	380	case Binding.FIELD : // reading a field
372	FieldBinding codegenField = ((FieldBinding) this.binding).original();	381	FieldBinding codegenField = ((FieldBinding) this.binding).original();
		382	reportOnlyUselesslyReadPrivateField(currentScope, codegenField, valueRequired);
373	Constant fieldConstant = codegenField.constant();	383	Constant fieldConstant = codegenField.constant();
374	if (fieldConstant != Constant.NotAConstant) {	384	if (fieldConstant != Constant.NotAConstant) {
375	// directly use inlined value for constant fields	385	// directly use inlined value for constant fields
Lines 423-433 Link Here
423	break;	433	break;
424	case Binding.LOCAL : // reading a local	434	case Binding.LOCAL : // reading a local
425	LocalVariableBinding localBinding = (LocalVariableBinding) this.binding;	435	LocalVariableBinding localBinding = (LocalVariableBinding) this.binding;
		436	Reference.reportOnlyUselesslyReadLocal(currentScope, localBinding, valueRequired);
426	if (localBinding.resolvedPosition == -1) {	437	if (localBinding.resolvedPosition == -1) {
427	if (valueRequired) {	438	if (valueRequired) {
428	// restart code gen	439	// restart code gen
429	localBinding.useFlag = LocalVariableBinding.USED;	440	localBinding.useFlag = LocalVariableBinding.USED;
430	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);	441	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null, localBinding.declaringScope.methodScope());
431	}	442	}
432	codeStream.recordPositionsFrom(pc, this.sourceStart);	443	codeStream.recordPositionsFrom(pc, this.sourceStart);
433	return;	444	return;
Lines 554-560 Link Here
554	* - the constant can have potential side-effect	565	* - the constant can have potential side-effect
555	*/	566	*/
556	localBinding.useFlag = LocalVariableBinding.USED;	567	localBinding.useFlag = LocalVariableBinding.USED;
557	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);	568	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null, localBinding.declaringScope.methodScope());
558	} else if (assignConstant == Constant.NotAConstant) {	569	} 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	570	// 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);	571	expression.generateCode(currentScope, codeStream, false);
Lines 733-739 Link Here
733	if (valueRequired) {	744	if (valueRequired) {
734	// restart code gen	745	// restart code gen
735	localBinding.useFlag = LocalVariableBinding.USED;	746	localBinding.useFlag = LocalVariableBinding.USED;
736	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);	747	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null, localBinding.declaringScope.methodScope());
737	}	748	}
738	return;	749	return;
739	}	750	}
Lines 807-817 Link Here
807	// local was tagged as uninitialized	818	// local was tagged as uninitialized
808	return;	819	return;
809	}	820	}
810	switch(localVariableBinding.useFlag) {	821	currentScope.emulateOuterAccess(localVariableBinding);
811	case LocalVariableBinding.FAKE_USED :
812	case LocalVariableBinding.USED :
813	currentScope.emulateOuterAccess(localVariableBinding);
814	}
815	}	822	}
816	}	823	}
817	}	824	}
Lines 914-919 Link Here
914	}	921	}
915		922
916	public TypeBinding resolveType(BlockScope scope) {	923	public TypeBinding resolveType(BlockScope scope) {
		924	if (scope.isInsideCondition)
		925	this.bits \|= ASTNode.IsInsideCondition;
917	// for code gen, harm the restrictiveFlag	926	// for code gen, harm the restrictiveFlag
918		927
919	if (this.actualReceiverType != null) {	928	if (this.actualReceiverType != null) {

Lines 162-168 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java (-2 / +10 lines)
162	codeStream.pop();	162	codeStream.pop();
163	}	163	}
164	} else {	164	} else {
165	valueRequired = this.expression.constant == Constant.NotAConstant \|\| hasCases;	165	valueRequired = hasCases \|\|
		166	((this.expression.constant == Constant.NotAConstant)
		167	&& (this.expression.implicitConversion & TypeIds.UNBOXING) != 0);
166	// generate expression	168	// generate expression
167	this.expression.generateCode(currentScope, codeStream, valueRequired);	169	this.expression.generateCode(currentScope, codeStream, valueRequired);
168	}	170	}
Lines 267-273 Link Here
267	public void resolve(BlockScope upperScope) {	269	public void resolve(BlockScope upperScope) {
268	try {	270	try {
269	boolean isEnumSwitch = false;	271	boolean isEnumSwitch = false;
270	TypeBinding expressionType = this.expression.resolveType(upperScope);	272	TypeBinding expressionType = null;
		273	try {
		274	upperScope.isInsideCondition = true;
		275	expressionType = this.expression.resolveType(upperScope);
		276	} finally {
		277	upperScope.isInsideCondition = false;
		278	}
271	if (expressionType != null) {	279	if (expressionType != null) {
272	this.expression.computeConversion(upperScope, expressionType, expressionType);	280	this.expression.computeConversion(upperScope, expressionType, expressionType);
273	checkType: {	281	checkType: {

Lines 498-505 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java (-1 / +4 lines)
498	public void generateCode(ClassFile enclosingClassFile) {	498	public void generateCode(ClassFile enclosingClassFile) {
499	if ((this.bits & ASTNode.HasBeenGenerated) != 0)	499	if ((this.bits & ASTNode.HasBeenGenerated) != 0)
500	return;	500	return;
501	this.bits \|= ASTNode.HasBeenGenerated;
502	if (this.ignoreFurtherInvestigation) {	501	if (this.ignoreFurtherInvestigation) {
		502	this.bits \|= ASTNode.HasBeenGenerated;
503	if (this.binding == null)	503	if (this.binding == null)
504	return;	504	return;
505	ClassFile.createProblemType(	505	ClassFile.createProblemType(
Lines 554-559 Link Here
554	this.scope.referenceCompilationUnit().compilationResult.record(	554	this.scope.referenceCompilationUnit().compilationResult.record(
555	this.binding.constantPoolName(),	555	this.binding.constantPoolName(),
556	classFile);	556	classFile);
		557	this.bits \|= ASTNode.HasBeenGenerated;
		558	} catch(AbortMethod e) {
		559	throw e;
557	} catch (AbortType e) {	560	} catch (AbortType e) {
558	if (this.binding == null)	561	if (this.binding == null)
559	return;	562	return;

Lines 254-261 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/WhileStatement.java (-2 / +7 lines)
254	}	254	}
255		255
256	public void resolve(BlockScope scope) {	256	public void resolve(BlockScope scope) {
257		257	TypeBinding type = null;
258	TypeBinding type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);	258	try {
		259	scope.isInsideCondition = true;
		260	type = this.condition.resolveTypeExpecting(scope, TypeBinding.BOOLEAN);
		261	} finally {
		262	scope.isInsideCondition = false;
		263	}
259	this.condition.computeConversion(scope, type, type);	264	this.condition.computeConversion(scope, type, type);
260	if (this.action != null)	265	if (this.action != null)
261	this.action.resolve(scope);	266	this.action.resolve(scope);

Lines 2263-2269 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java (-5 / +21 lines)
2263	aload_0();	2263	aload_0();
2264	fieldAccess(Opcodes.OPC_getfield, fieldBinding, null /* default declaringClass */);	2264	fieldAccess(Opcodes.OPC_getfield, fieldBinding, null /* default declaringClass */);
2265	} else {	2265	} else {
2266	load((LocalVariableBinding) mappingSequence[0]);	2266	LocalVariableBinding localBinding = (LocalVariableBinding) mappingSequence[0];
		2267	if (localBinding.resolvedPosition != -1) {
		2268	load(localBinding);
		2269	}
2267	}	2270	}
2268	for (int i = 1, length = mappingSequence.length; i < length; i++) {	2271	for (int i = 1, length = mappingSequence.length; i < length; i++) {
2269	if (mappingSequence[i] instanceof FieldBinding) {	2272	if (mappingSequence[i] instanceof FieldBinding) {
Lines 2388-2394 Link Here
2388	SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticOuterLocalVariables();	2391	SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticOuterLocalVariables();
2389	for (int i = 0; i < (syntheticArguments == null ? 0 : syntheticArguments.length); i++) {	2392	for (int i = 0; i < (syntheticArguments == null ? 0 : syntheticArguments.length); i++) {
2390	TypeBinding type;	2393	TypeBinding type;
2391	load(type = syntheticArguments[i].type, resolvedPosition);	2394	SyntheticArgumentBinding syntheticArgumentBinding = syntheticArguments[i];
		2395	LocalVariableBinding actualOuterLocalVariable = syntheticArgumentBinding.actualOuterLocalVariable;
		2396	if (actualOuterLocalVariable != null && actualOuterLocalVariable.resolvedPosition == -1) {
		2397	continue;
		2398	}
		2399	load(type = syntheticArgumentBinding.type, resolvedPosition);
2392	switch(type.id) {	2400	switch(type.id) {
2393	case TypeIds.T_long :	2401	case TypeIds.T_long :
2394	case TypeIds.T_double :	2402	case TypeIds.T_double :
Lines 2709-2714 Link Here
2709	if ((syntheticArguments = targetType.syntheticOuterLocalVariables()) != null) {	2717	if ((syntheticArguments = targetType.syntheticOuterLocalVariables()) != null) {
2710	for (int i = 0, max = syntheticArguments.length; i < max; i++) {	2718	for (int i = 0, max = syntheticArguments.length; i < max; i++) {
2711	LocalVariableBinding targetVariable = syntheticArguments[i].actualOuterLocalVariable;	2719	LocalVariableBinding targetVariable = syntheticArguments[i].actualOuterLocalVariable;
		2720	if (targetVariable == null \|\| targetVariable.resolvedPosition == -1) {
		2721	continue;
		2722	}
2712	VariableBinding[] emulationPath = currentScope.getEmulationPath(targetVariable);	2723	VariableBinding[] emulationPath = currentScope.getEmulationPath(targetVariable);
2713	generateOuterAccess(emulationPath, invocationSite, targetVariable, currentScope);	2724	generateOuterAccess(emulationPath, invocationSite, targetVariable, currentScope);
2714	}	2725	}
Lines 3860-3866 Link Here
3860	SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticOuterLocalVariables();	3871	SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticOuterLocalVariables();
3861	if (syntheticArguments != null) {	3872	if (syntheticArguments != null) {
3862	for (int i = 0, max = syntheticArguments.length; i < max; i++) {	3873	for (int i = 0, max = syntheticArguments.length; i < max; i++) {
3863	switch (syntheticArguments[i].id) {	3874	SyntheticArgumentBinding syntheticArgumentBinding = syntheticArguments[i];
		3875	LocalVariableBinding actualOuterLocalVariable = syntheticArgumentBinding.actualOuterLocalVariable;
		3876	if (actualOuterLocalVariable == null \|\| actualOuterLocalVariable.resolvedPosition == -1) {
		3877	continue;
		3878	}
		3879	switch (syntheticArgumentBinding.id) {
3864	case TypeIds.T_double :	3880	case TypeIds.T_double :
3865	case TypeIds.T_long :	3881	case TypeIds.T_long :
3866	receiverAndArgsSize += 2;	3882	receiverAndArgsSize += 2;
Lines 3868-3874 Link Here
3868	default:	3884	default:
3869	receiverAndArgsSize++;	3885	receiverAndArgsSize++;
3870	break;	3886	break;
3871	}	3887	}
3872	}	3888	}
3873	}	3889	}
3874	}	3890	}
Lines 3876-3882 Link Here
3876	// adding String (name) and int (ordinal)	3892	// adding String (name) and int (ordinal)
3877	receiverAndArgsSize += 2;	3893	receiverAndArgsSize += 2;
3878	}	3894	}
3879	}	3895	}
3880	break;	3896	break;
3881	default :	3897	default :
3882	return; // should not occur	3898	return; // should not occur

Lines 35-40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BlockScope.java (-2 / +8 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 894-903 Link Here
894	if ((syntheticArguments = targetType.syntheticOuterLocalVariables()) != null) {	896	if ((syntheticArguments = targetType.syntheticOuterLocalVariables()) != null) {
895	for (int i = 0, max = syntheticArguments.length; i < max; i++) {	897	for (int i = 0, max = syntheticArguments.length; i < max; i++) {
896	SyntheticArgumentBinding syntheticArg = syntheticArguments[i];	898	SyntheticArgumentBinding syntheticArg = syntheticArguments[i];
		899	LocalVariableBinding outerLocalVariable = syntheticArg.actualOuterLocalVariable;
897	// need to filter out the one that could match a supplied enclosing instance	900	// need to filter out the one that could match a supplied enclosing instance
898	if (!(isEnclosingInstanceSupplied	901	if (!(isEnclosingInstanceSupplied
899	&& (syntheticArg.type == targetType.enclosingType()))) {	902	&& (syntheticArg.type == targetType.enclosingType()))) {
900	emulateOuterAccess(syntheticArg.actualOuterLocalVariable);	903	if (outerLocalVariable == null \|\| outerLocalVariable.resolvedPosition == -1) {
		904	continue;
		905	}
		906	emulateOuterAccess(outerLocalVariable);
901	}	907	}
902	}	908	}
903	}	909	}

Lines 887-893 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java (-2 / +15 lines)
887	SyntheticArgumentBinding[] syntheticOuterArguments = this.declaringClass.syntheticOuterLocalVariables();	887	SyntheticArgumentBinding[] syntheticOuterArguments = this.declaringClass.syntheticOuterLocalVariables();
888	int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;	888	int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;
889	for (int i = 0; i < count; i++) {	889	for (int i = 0; i < count; i++) {
890	buffer.append(syntheticOuterArguments[i].type.signature());	890	SyntheticArgumentBinding syntheticArgumentBinding = syntheticOuterArguments[i];
		891	LocalVariableBinding actualOuterLocalVariable = syntheticArgumentBinding.actualOuterLocalVariable;
		892	if (actualOuterLocalVariable == null \|\| actualOuterLocalVariable.resolvedPosition == -1) {
		893	continue;
		894	}
		895	buffer.append(syntheticArgumentBinding.type.signature());
891	}	896	}
892	// move the extra padding arguments of the synthetic constructor invocation to the end	897	// move the extra padding arguments of the synthetic constructor invocation to the end
893	for (int i = targetParameters.length, extraLength = this.parameters.length; i < extraLength; i++) {	898	for (int i = targetParameters.length, extraLength = this.parameters.length; i < extraLength; i++) {
Lines 1005-1011 Link Here
1005	SyntheticArgumentBinding[] syntheticOuterArguments = this.declaringClass.syntheticOuterLocalVariables();	1010	SyntheticArgumentBinding[] syntheticOuterArguments = this.declaringClass.syntheticOuterLocalVariables();
1006	int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;	1011	int count = syntheticOuterArguments == null ? 0 : syntheticOuterArguments.length;
1007	for (int i = 0; i < count; i++) {	1012	for (int i = 0; i < count; i++) {
1008	buffer.append(syntheticOuterArguments[i].type.signature());	1013	SyntheticArgumentBinding syntheticArgumentBinding = syntheticOuterArguments[i];
		1014	LocalVariableBinding actualOuterLocalVariable = syntheticArgumentBinding.actualOuterLocalVariable;
		1015	if (actualOuterLocalVariable == null \|\| actualOuterLocalVariable.resolvedPosition == -1) {
		1016	continue;
		1017	}
		1018	buffer.append(syntheticArgumentBinding.type.signature());
1009	}	1019	}
1010	// move the extra padding arguments of the synthetic constructor invocation to the end	1020	// move the extra padding arguments of the synthetic constructor invocation to the end
1011	for (int i = targetParameters.length, extraLength = this.parameters.length; i < extraLength; i++) {	1021	for (int i = targetParameters.length, extraLength = this.parameters.length; i < extraLength; i++) {
Lines 1118-1121 Link Here
1118	public TypeVariableBinding[] typeVariables() {	1128	public TypeVariableBinding[] typeVariables() {
1119	return this.typeVariables;	1129	return this.typeVariables;
1120	}	1130	}
		1131	public void resetSignature() {
		1132	this.signature = null;
		1133	}
1121	}	1134	}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/NestedTypeBinding.java (-2 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 127-134 Link Here
127	if (this.outerLocalVariablesSlotSize < 0) {	127	if (this.outerLocalVariablesSlotSize < 0) {
128	this.outerLocalVariablesSlotSize = 0;	128	this.outerLocalVariablesSlotSize = 0;
129	int outerLocalsCount = this.outerLocalVariables == null ? 0 : this.outerLocalVariables.length;	129	int outerLocalsCount = this.outerLocalVariables == null ? 0 : this.outerLocalVariables.length;
130	for (int i = 0; i < outerLocalsCount; i++){	130	for (int i = 0; i < outerLocalsCount; i++) {
131	SyntheticArgumentBinding argument = this.outerLocalVariables[i];	131	SyntheticArgumentBinding argument = this.outerLocalVariables[i];
		132	LocalVariableBinding outerLocalVariable = argument.actualOuterLocalVariable;
		133	if (outerLocalVariable == null \|\| outerLocalVariable.resolvedPosition == -1) {
		134	continue;
		135	}
132	switch (argument.type.id) {	136	switch (argument.type.id) {
133	case TypeIds.T_long :	137	case TypeIds.T_long :
134	case TypeIds.T_double :	138	case TypeIds.T_double :




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.lookup.Scope;

/*
 * Special unchecked exception type used

public class AbortMethod extends AbortType {

	private static final long serialVersionUID = -1480267398969840003L; // backward compatible
	private Scope scope;

public AbortMethod(CompilationResult compilationResult, CategorizedProblem problem) {
	super(compilationResult, problem);
}
public AbortMethod(CompilationResult compilationResult, CategorizedProblem problem, Scope scope) {
	super(compilationResult, problem);
	this.scope = scope;
}
public Scope getScope() {
	return this.scope;
}
}

Lines 275-281 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetSingleNameReference.java (-2 / +2 lines)
275	if (valueRequired) {	275	if (valueRequired) {
276	// restart code gen	276	// restart code gen
277	localBinding.useFlag = LocalVariableBinding.USED;	277	localBinding.useFlag = LocalVariableBinding.USED;
278	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);	278	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null, localBinding.declaringScope.methodScope());
279	}	279	}
280	codeStream.recordPositionsFrom(pc, this.sourceStart);	280	codeStream.recordPositionsFrom(pc, this.sourceStart);
281	return;	281	return;
Lines 370-376 Link Here
370	* - the constant can have potential side-effect	370	* - the constant can have potential side-effect
371	*/	371	*/
372	localBinding.useFlag = LocalVariableBinding.USED;	372	localBinding.useFlag = LocalVariableBinding.USED;
373	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null);	373	throw new AbortMethod(CodeStream.RESTART_CODE_GEN_FOR_UNUSED_LOCALS_MODE, null, localBinding.declaringScope.methodScope());
374	} else if (assignConstant == Constant.NotAConstant) {	374	} else if (assignConstant == Constant.NotAConstant) {
375	// we only need to generate the value of the expression's constant if it is not a constant expression	375	// we only need to generate the value of the expression's constant if it is not a constant expression
376	expression.generateCode(currentScope, codeStream, false);	376	expression.generateCode(currentScope, codeStream, false);




/*******************************************************************************
 * Copyright (c) 2000, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 */
public void generateCode(ClassFile enclosingClassFile) {
	if ((this.bits & ASTNode.HasBeenGenerated) != 0) return;
	this.bits |= ASTNode.HasBeenGenerated;

	if (this.ignoreFurtherInvestigation) {
		this.bits |= ASTNode.HasBeenGenerated;
		if (this.binding == null)
			return;
		CodeSnippetClassFile.createProblemType(this, this.scope.referenceCompilationUnit().compilationResult);

		// finalize the compiled type result
		classFile.addAttributes();
		this.scope.referenceCompilationUnit().compilationResult.record(this.binding.constantPoolName(), classFile);
		this.bits |= ASTNode.HasBeenGenerated;
	} catch (AbortType e) {
		if (this.binding == null)
			return;

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




public class ProgrammingProblemsTest extends AbstractRegressionTest {

public ProgrammingProblemsTest(String name) {
	super(name);
}

	// Static initializer to specify tests subset using TESTS_* static variables
	// All specified tests which does not belong to the class are skipped...
	// 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[] { "test0055" };
//		TESTS_NUMBERS = new int[] { 73 };
//  	TESTS_RANGE = new int[] { 66, -1 };
	}

public static Test suite() {
    return buildAllCompliancesTestSuite(testClass());

		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(a++ > 10 && false) {\n" + // not counted as relevant use since bug 185682
			"		} 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, 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, exprOfForWhileSwitch
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 (this.a++>10 && false) {\n" +
			" 		}\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, exprOfForWhileSwitch
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" +
			" 		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",
			"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) { System.out.print(4); }\n" + 	// value is used
			"            }\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: 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);
	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, 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" + 
			"2. WARNING in X.java (at line 4)\n" + // FIXME(SH): duplicate report due to restart (AbortMethod) 
			"	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 signaled by AbortMethod
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 #13 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\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  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 #13 (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 [15]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [17]\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 #12 (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 [14]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [16]\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 signaled by AbortMethod
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 #13 (LX;)V\n" + 
			"  // Stack: 2, Locals: 2\n" + 
			"  X$1(X arg0);\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  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 #13 (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 [15]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [17]\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 #12 (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 [14]\n" + 
			"     5  aload_0 [this]\n" + 
			"     6  invokespecial java.lang.Object() [16]\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 signaled by AbortMethod
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 signaled by AbortMethod
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 signaled by AbortMethod
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);
}
}

Return to bug 328830