Attachment #187094 for bug #247564




    /** @since 3.4 */
    int UnusedTypeArgumentsForConstructorInvocation = MethodRelated + 660;

    /**
	 * Null analysis for fields
	 */
    /** @since 3.7 */
	int NullFieldReference = Internal + FieldRelated + 670;
	/** @since 3.7 */
	int PotentialNullFieldReference = Internal + FieldRelated + 671;
	/** @since 3.7 */
	int RedundantNullCheckOnNullField = Internal + FieldRelated + 672;
	/** @since 3.7 */
	int NullFieldComparisonYieldsFalse = Internal + FieldRelated + 673;
	/** @since 3.7 */
	int RedundantNullCheckOnNonNullField = Internal + FieldRelated + 674;
	/** @since 3.7 */
	int NonNullFieldComparisonYieldsFalse = Internal + FieldRelated + 675;
	/** @since 3.7 */
	int RedundantFieldNullAssignment = Internal + FieldRelated + 676;
	/** @since 3.7 */
	int NullFieldInstanceofYieldsFalse = Internal + FieldRelated + 677;
	
	/**
	 * Corrupted binaries
	 */

Lines 38-44 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java (-1 / +10 lines)
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.
41	LocalVariableBinding local = this.lhs.localVariableBinding();	41	VariableBinding local = this.lhs.variableBinding();
42	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	42	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
43	this.expression.checkNPE(currentScope, flowContext, flowInfo);	43	this.expression.checkNPE(currentScope, flowContext, flowInfo);
44	}	44	}
Lines 56-61 Link Here
56	flowInfo.markNullStatus(local, nullStatus);	56	flowInfo.markNullStatus(local, nullStatus);
57	if (flowContext.initsOnFinally != null)	57	if (flowContext.initsOnFinally != null)
58	flowContext.initsOnFinally.markNullStatus(local, nullStatus);	58	flowContext.initsOnFinally.markNullStatus(local, nullStatus);
		59	if (local instanceof FieldBinding && local.isFinal() && ((FieldBinding) local).isStatic()) {
		60	// static final field being assigned. Record its null status for future reference
		61	// since the flowInfo from a constructor or static block wont be available in a method
		62	FieldBinding fieldBinding = (FieldBinding) local;
		63	fieldBinding.setNullStatusForStaticFinalField(nullStatus);
		64	}
59	}	65	}
60	return flowInfo;	66	return flowInfo;
61	}	67	}
Lines 205-208 Link Here
205	public LocalVariableBinding localVariableBinding() {	211	public LocalVariableBinding localVariableBinding() {
206	return this.lhs.localVariableBinding();	212	return this.lhs.localVariableBinding();
207	}	213	}
		214	public VariableBinding variableBinding() {
		215	return this.lhs.variableBinding();
		216	}
208	}	217	}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (-1 / +3 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 36-41 Link Here
36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);	36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);
37	}	37	}
38	}	38	}
		39	// don't let the flow info collected for fields from this block persist.
		40	flowInfo.resetNullInfoForFields();
39	return flowInfo;	41	return flowInfo;
40	}	42	}
41	/**	43	/**

Lines 32-37 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/CastExpression.java (+8 lines)
32	import org.eclipse.jdt.internal.compiler.lookup.TagBits;	32	import org.eclipse.jdt.internal.compiler.lookup.TagBits;
33	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	33	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
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.lookup.VariableBinding;
35	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;	36	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
36		37
37	public class CastExpression extends Expression {	38	public class CastExpression extends Expression {
Lines 444-449 Link Here
444	return this.expression.localVariableBinding();	445	return this.expression.localVariableBinding();
445	}	446	}
446		447
		448	/**
		449	* @see org.eclipse.jdt.internal.compiler.ast.Expression#variableBinding()
		450	*/
		451	public VariableBinding variableBinding() {
		452	return this.expression.variableBinding();
		453	}
		454
447	public int nullStatus(FlowInfo flowInfo) {	455	public int nullStatus(FlowInfo flowInfo) {
448	return this.expression.nullStatus(flowInfo);	456	return this.expression.nullStatus(flowInfo);
449	}	457	}




	}
	private void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {

		VariableBinding local = this.left.variableBinding();
		if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
			checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.right.nullStatus(flowInfo), this.left);
		}
		local = this.right.variableBinding();
		if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
			checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.left.nullStatus(flowInfo), this.right);
		}
	}
	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, VariableBinding local, int nullStatus, Expression reference) {
		switch (nullStatus) {
			case FlowInfo.NULL :
				if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
					flowContext.recordUsingNullReference(scope, local, reference,
							FlowContext.CAN_ONLY_NULL_NON_NULL | FlowContext.IN_COMPARISON_NULL, flowInfo);
					initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set
					initsWhenFalse.markAsComparedEqualToNonNull(local ); // from thereon it is set
				} else {
					flowContext.recordUsingNullReference(scope, local, reference,
							FlowContext.CAN_ONLY_NULL_NON_NULL | FlowContext.IN_COMPARISON_NON_NULL, flowInfo);




import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
import org.eclipse.jdt.internal.compiler.problem.ShouldNotImplement;
import org.eclipse.jdt.internal.compiler.util.Messages;

 * @param flowInfo the upstream flow info; caveat: may get modified
 */
public void checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo) {
	VariableBinding local = variableBinding();
	if (local != null &&
			(local.type.tagBits & TagBits.IsBaseType) == 0) {
		if ((this.bits & ASTNode.IsNonNull) == 0) {
			flowContext.recordUsingNullReference(scope, local, this,
					FlowContext.MAY_NULL, flowInfo);
		}
		flowInfo.markAsComparedEqualToNonNull(local );
			// from thereon it is set
		if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
			flowInfo.markedAsNullOrNonNullInAssertExpression(local);

		this.constant != null && this.constant != Constant.NotAConstant)
	return FlowInfo.NON_NULL; // constant expression cannot be null

	VariableBinding local = variableBinding();
	if (local != null)
		return flowInfo.nullStatus(local);
	return FlowInfo.NON_NULL;

public void traverse(ASTVisitor visitor, ClassScope scope) {
	// nothing to do
}

/**
 * Returns the field or local variable referenced by this node. Can be a direct reference (SingleNameReference)
 * or thru a cast expression etc...
 */
public VariableBinding variableBinding() {
	return null;
}
}

Lines 74-79 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldDeclaration.java (+7 lines)
74	.analyseCode(initializationScope, flowContext, flowInfo)	74	.analyseCode(initializationScope, flowContext, flowInfo)
75	.unconditionalInits();	75	.unconditionalInits();
76	flowInfo.markAsDefinitelyAssigned(this.binding);	76	flowInfo.markAsDefinitelyAssigned(this.binding);
		77	if (this.binding.isFinal() && this.binding.isStatic()) {
		78	int nullStatus = this.initialization.nullStatus(flowInfo);
		79	// static final field being initialized. Record its null status for future reference
		80	// since the flowInfo from an initialization wont be available in a method
		81
		82	this.binding.setNullStatusForStaticFinalField(nullStatus);
		83	}
77	}	84	}
78	return flowInfo;	85	return flowInfo;
79	}	86	}




/*******************************************************************************
 * Copyright (c) 2000, 2011 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.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;

public class FieldReference extends Reference implements InvocationSite {


	}
	visitor.endVisit(this, scope);
}

public VariableBinding variableBinding() {
	if (this.receiver.isThis() || this.binding.isStatic()) {
		if (this.receiver instanceof MessageSend) {
			if (((MessageSend) this.receiver).actualReceiverType == this.receiver.resolvedType) {
				return this.binding;
			}
		} else {
			return this.binding;
		}
	}
	return super.variableBinding();
}

}




}

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
	VariableBinding variable = this.expression.variableBinding();
	if (variable != null && (variable.type.tagBits & TagBits.IsBaseType) == 0) {
		flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo).
			unconditionalInits();
		FlowInfo initsWhenTrue = flowInfo.copy();
		initsWhenTrue.markAsComparedEqualToNonNull(variable );
		if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
			initsWhenTrue.markedAsNullOrNonNullInAssertExpression(variable);
		}
		flowContext.recordUsingNullReference(currentScope, variable,
				this.expression, FlowContext.CAN_ONLY_NULL | FlowContext.IN_INSTANCEOF, flowInfo);
		// no impact upon enclosing try context
		return FlowInfo.conditional(initsWhenTrue, flowInfo.copy());

Lines 95-100 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (+3 lines)
95	// NullReferenceTest#test0510	95	// NullReferenceTest#test0510
96	}	96	}
97	manageSyntheticAccessIfNecessary(currentScope, flowInfo);	97	manageSyntheticAccessIfNecessary(currentScope, flowInfo);
		98	// a method call can result in changed values for fields,
		99	// so wipe out null info for fields collected till now.
		100	flowInfo.resetNullInfoForFields();
98	return flowInfo;	101	return flowInfo;
99	}	102	}
100	/**	103	/**




	return null;
}

public VariableBinding variableBinding() {
	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
		case Binding.FIELD : 
			// reading a field
		case Binding.LOCAL : // reading a local variable
			return (VariableBinding) this.binding;
	}
	return null;
}
public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
	//If inlinable field, forget the access emulation, the code gen will directly target it
	if (((this.bits & ASTNode.DepthMASK) == 0) || (this.constant != Constant.NotAConstant)) {

	}
	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
		case Binding.FIELD : // reading a field
			return FlowInfo.UNKNOWN;
		case Binding.LOCAL : // reading a local variable
			VariableBinding variable = (VariableBinding) this.binding;
			if (variable != null)
				return flowInfo.nullStatus(variable);
	}
	return FlowInfo.NON_NULL; // never get there
}

Lines 43-48 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java (-4 / +84 lines)
43	public MethodScope staticInitializerScope;	43	public MethodScope staticInitializerScope;
44	public boolean ignoreFurtherInvestigation = false;	44	public boolean ignoreFurtherInvestigation = false;
45	public int maxFieldCount;	45	public int maxFieldCount;
		46	public int maxFieldCountForFlowInfo; // cumulative count of fields in this type and enclosing types
46	public int declarationSourceStart;	47	public int declarationSourceStart;
47	public int declarationSourceEnd;	48	public int declarationSourceEnd;
48	public int bodyStart;	49	public int bodyStart;
Lines 198-204 Link Here
198	localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));	199	localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));
199	}	200	}
200	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);	201	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
		202
		203	ClassScope enclosingClass = currentScope.classScope();
		204	if (enclosingClass.referenceContext != null) {
		205	this.maxFieldCountForFlowInfo = enclosingClass.referenceContext.maxFieldCountForFlowInfo + this.maxFieldCount;
		206	} else {
		207	this.maxFieldCountForFlowInfo = this.maxFieldCount;
		208	}
201	updateMaxFieldCount(); // propagate down the max field count	209	updateMaxFieldCount(); // propagate down the max field count
		210	flowInfo.unconditionalInits().maxFieldCount = this.maxFieldCountForFlowInfo;
202	internalAnalyseCode(flowContext, flowInfo);	211	internalAnalyseCode(flowContext, flowInfo);
203	} catch (AbortType e) {	212	} catch (AbortType e) {
204	this.ignoreFurtherInvestigation = true;	213	this.ignoreFurtherInvestigation = true;
Lines 214-222 Link Here
214	if (this.ignoreFurtherInvestigation)	223	if (this.ignoreFurtherInvestigation)
215	return;	224	return;
216	try {	225	try {
		226	if (this.enclosingType == null) {
		227	this.maxFieldCountForFlowInfo = this.maxFieldCount;
		228	} else {
		229	this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
		230	}
217	// propagate down the max field count	231	// propagate down the max field count
218	updateMaxFieldCount();	232	updateMaxFieldCount();
219	internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCount));	233	internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCountForFlowInfo));
220	} catch (AbortType e) {	234	} catch (AbortType e) {
221	this.ignoreFurtherInvestigation = true;	235	this.ignoreFurtherInvestigation = true;
222	}	236	}
Lines 236-242 Link Here
236	localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));	250	localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));
237	}	251	}
238	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);	252	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
		253
		254	if (this.enclosingType == null) {
		255	this.maxFieldCountForFlowInfo = this.maxFieldCount;
		256	} else {
		257	this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
		258	}
239	updateMaxFieldCount(); // propagate down the max field count	259	updateMaxFieldCount(); // propagate down the max field count
		260	flowInfo.unconditionalInits().maxFieldCount = this.maxFieldCountForFlowInfo;
240	internalAnalyseCode(flowContext, flowInfo);	261	internalAnalyseCode(flowContext, flowInfo);
241	} catch (AbortType e) {	262	} catch (AbortType e) {
242	this.ignoreFurtherInvestigation = true;	263	this.ignoreFurtherInvestigation = true;
Lines 251-257 Link Here
251	if (this.ignoreFurtherInvestigation)	272	if (this.ignoreFurtherInvestigation)
252	return;	273	return;
253	try {	274	try {
254	internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCount));	275	if (this.enclosingType == null) {
		276	this.maxFieldCountForFlowInfo = this.maxFieldCount;
		277	} else {
		278	this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
		279	}
		280	internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCountForFlowInfo));
255	} catch (AbortType e) {	281	} catch (AbortType e) {
256	this.ignoreFurtherInvestigation = true;	282	this.ignoreFurtherInvestigation = true;
257	}	283	}
Lines 646-652 Link Here
646	// branch, since the previous initializer already got the blame.	672	// branch, since the previous initializer already got the blame.
647	if (staticFieldInfo == FlowInfo.DEAD_END) {	673	if (staticFieldInfo == FlowInfo.DEAD_END) {
648	this.staticInitializerScope.problemReporter().initializerMustCompleteNormally(field);	674	this.staticInitializerScope.problemReporter().initializerMustCompleteNormally(field);
649	staticFieldInfo = FlowInfo.initial(this.maxFieldCount).setReachMode(FlowInfo.UNREACHABLE);	675	staticFieldInfo = FlowInfo.initial(this.maxFieldCountForFlowInfo).setReachMode(FlowInfo.UNREACHABLE);
650	}	676	}
651	} else {	677	} else {
652	if ((nonStaticFieldInfo.tagBits & FlowInfo.UNREACHABLE) != 0)	678	if ((nonStaticFieldInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
Lines 662-668 Link Here
662	// branch, since the previous initializer already got the blame.	688	// branch, since the previous initializer already got the blame.
663	if (nonStaticFieldInfo == FlowInfo.DEAD_END) {	689	if (nonStaticFieldInfo == FlowInfo.DEAD_END) {
664	this.initializerScope.problemReporter().initializerMustCompleteNormally(field);	690	this.initializerScope.problemReporter().initializerMustCompleteNormally(field);
665	nonStaticFieldInfo = FlowInfo.initial(this.maxFieldCount).setReachMode(FlowInfo.UNREACHABLE);	691	nonStaticFieldInfo = FlowInfo.initial(this.maxFieldCountForFlowInfo).setReachMode(FlowInfo.UNREACHABLE);
666	}	692	}
667	}	693	}
668	}	694	}
Lines 1087-1092 Link Here
1087	if (this.maxFieldCount < localMaxFieldCount) {	1113	if (this.maxFieldCount < localMaxFieldCount) {
1088	this.maxFieldCount = localMaxFieldCount;	1114	this.maxFieldCount = localMaxFieldCount;
1089	}	1115	}
		1116	// if (this.memberTypes != null) {
		1117	// for (int i = 0, count = this.memberTypes.length; i < count; i++) {
		1118	// this.memberTypes[i].maxFieldCount += this.maxFieldCount;
		1119	// }
		1120	// }
		1121	// field count from supertypes should be included in maxFieldCount,
		1122	// so that a field from supertype doesn't end up with same id as a local variable
		1123	// in a method being analyzed.
		1124	ReferenceBinding superClassBinding = sourceType.superclass;
		1125	while (superClassBinding != null) {
		1126	FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
		1127	if (unResolvedFields != null) {
		1128	this.maxFieldCount += unResolvedFields.length;
		1129	}
		1130	superClassBinding = superClassBinding.superclass();
		1131	}
		1132	ReferenceBinding[] superInterfacesBinding = this.binding.superInterfaces;
		1133	this.maxFieldCount += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		1134	// if (this.enclosingType != null)
		1135	// this.maxFieldCount += this.enclosingType.maxFieldCount;
		1136
1090	if (needSerialVersion) {	1137	if (needSerialVersion) {
1091	//check that the current type doesn't extend javax.rmi.CORBA.Stub	1138	//check that the current type doesn't extend javax.rmi.CORBA.Stub
1092	TypeBinding javaxRmiCorbaStub = this.scope.getType(TypeConstants.JAVAX_RMI_CORBA_STUB, 4);	1139	TypeBinding javaxRmiCorbaStub = this.scope.getType(TypeConstants.JAVAX_RMI_CORBA_STUB, 4);
Lines 1173-1178 Link Here
1173	}	1220	}
1174	}	1221	}
1175		1222
		1223	private int findFieldCountFromSuperInterfaces(ReferenceBinding[] superinterfaces) {
		1224	int numOfFields = 0;
		1225	if (superinterfaces == null)
		1226	return numOfFields ;
		1227	for (int i = 0; i < superinterfaces.length; i++) {
		1228	numOfFields += superinterfaces[i].fieldCount();
		1229	numOfFields += findFieldCountFromSuperInterfaces(superinterfaces[i].superInterfaces());
		1230	}
		1231	return numOfFields;
		1232	}
		1233
1176	/**	1234	/**
1177	* Resolve a local type declaration	1235	* Resolve a local type declaration
1178	*/	1236	*/
Lines 1449-1456 Link Here
1449	} else {	1507	} else {
1450	this.maxFieldCount = outerMostType.maxFieldCount; // down	1508	this.maxFieldCount = outerMostType.maxFieldCount; // down
1451	}	1509	}
		1510
1452	}	1511	}
1453		1512
		1513	//int getMaxFieldCountForFlowInfo() {
		1514	// int maxFieldCountForFlowInfo = 0;
		1515	// if (this.binding == null)
		1516	// return maxFieldCountForFlowInfo; // error scenario
		1517	// ReferenceBinding superClassBinding = this.binding.superclass;
		1518	// while (superClassBinding != null) {
		1519	// FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
		1520	// if (unResolvedFields != null) {
		1521	// this.maxFieldCount += unResolvedFields.length;
		1522	// }
		1523	// superClassBinding = superClassBinding.superclass();
		1524	// }
		1525	// ReferenceBinding[] superInterfacesBinding = this.binding.superInterfaces;
		1526	// maxFieldCountForFlowInfo += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		1527	// if (this.enclosingType != null) {
		1528	// maxFieldCountForFlowInfo += this.enclosingType.maxFieldCount;
		1529	// }
		1530	// return maxFieldCountForFlowInfo;
		1531	//
		1532	//}
		1533
1454	/**	1534	/**
1455	* Returns whether the type is a secondary one or not.	1535	* Returns whether the type is a secondary one or not.
1456	*/	1536	*/





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

/**
 * Record conditional initialization status during definite assignment analysis

			&& this.initsWhenFalse.isDefinitelyAssigned(local);
}

public boolean isDefinitelyNonNull(VariableBinding local) {
	return this.initsWhenTrue.isDefinitelyNonNull(local)
			&& this.initsWhenFalse.isDefinitelyNonNull(local);
}

public boolean isDefinitelyNull(VariableBinding local) {
	return this.initsWhenTrue.isDefinitelyNull(local)
			&& this.initsWhenFalse.isDefinitelyNull(local);
}

public boolean isDefinitelyUnknown(VariableBinding local) {
	return this.initsWhenTrue.isDefinitelyUnknown(local)
			&& this.initsWhenFalse.isDefinitelyUnknown(local);
}

			|| this.initsWhenFalse.isPotentiallyAssigned(local);
}

public boolean isPotentiallyNonNull(VariableBinding local) {
	return this.initsWhenTrue.isPotentiallyNonNull(local)
		|| this.initsWhenFalse.isPotentiallyNonNull(local);
}

public boolean isPotentiallyNull(VariableBinding local) {
	return this.initsWhenTrue.isPotentiallyNull(local)
		|| this.initsWhenFalse.isPotentiallyNull(local);
}

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

public boolean isProtectedNonNull(VariableBinding local) {
	return this.initsWhenTrue.isProtectedNonNull(local)
		&& this.initsWhenFalse.isProtectedNonNull(local);
}

public boolean isProtectedNull(VariableBinding local) {
	return this.initsWhenTrue.isProtectedNull(local)
		&& this.initsWhenFalse.isProtectedNull(local);
}

public void markAsComparedEqualToNonNull(VariableBinding local) {
	this.initsWhenTrue.markAsComparedEqualToNonNull(local);
	this.initsWhenFalse.markAsComparedEqualToNonNull(local);
}

public void markAsComparedEqualToNull(VariableBinding local) {
	this.initsWhenTrue.markAsComparedEqualToNull(local);
    this.initsWhenFalse.markAsComparedEqualToNull(local);
}

	this.initsWhenFalse.markAsDefinitelyAssigned(local);
}

public void markAsDefinitelyNonNull(VariableBinding local) {
	this.initsWhenTrue.markAsDefinitelyNonNull(local);
	this.initsWhenFalse.markAsDefinitelyNonNull(local);
}

public void markAsDefinitelyNull(VariableBinding local) {
	this.initsWhenTrue.markAsDefinitelyNull(local);
	this.initsWhenFalse.markAsDefinitelyNull(local);
}

public void resetNullInfo(VariableBinding local) {
	this.initsWhenTrue.resetNullInfo(local);
	this.initsWhenFalse.resetNullInfo(local);
}

public void resetNullInfoForFields() {
	this.initsWhenTrue.resetNullInfoForFields();
	this.initsWhenFalse.resetNullInfoForFields();
}

public void markPotentiallyNullBit(VariableBinding local) {
	this.initsWhenTrue.markPotentiallyNullBit(local);
	this.initsWhenFalse.markPotentiallyNullBit(local);
}

public void markPotentiallyNonNullBit(VariableBinding local) {
	this.initsWhenTrue.markPotentiallyNonNullBit(local);
	this.initsWhenFalse.markPotentiallyNonNullBit(local);
}

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

public void markPotentiallyUnknownBit(VariableBinding local) {
	this.initsWhenTrue.markPotentiallyUnknownBit(local);
	this.initsWhenFalse.markPotentiallyUnknownBit(local);
}

			mergedWith(this.initsWhenFalse.unconditionalInits());
}

public void markedAsNullOrNonNullInAssertExpression(VariableBinding local) {
	this.initsWhenTrue.markedAsNullOrNonNullInAssertExpression(local);
	this.initsWhenFalse.markedAsNullOrNonNullInAssertExpression(local);
}

public boolean isMarkedAsNullOrNonNullInAssertExpression(VariableBinding local) {
	return (this.initsWhenTrue.isMarkedAsNullOrNonNullInAssertExpression(local)
		|| this.initsWhenFalse.isMarkedAsNullOrNonNullInAssertExpression(local));
}




	VariableBinding[] finalVariables;
	int assignCount;

	VariableBinding[] nullVariables;
	Expression[] nullReferences;
	int[] nullCheckTypes;
	int nullCount;

	// check inconsistent null checks
	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative
		for (int i = 0; i < this.nullCount; i++) {
			this.parent.recordUsingNullReference(scope, this.nullVariables[i],
					this.nullReferences[i],	this.nullCheckTypes[i], flowInfo);
		}
	}

		for (int i = 0; i < this.nullCount; i++) {
			Expression expression = this.nullReferences[i];
			// final local variable
			VariableBinding local = this.nullVariables[i];
			switch (this.nullCheckTypes[i]) {
				case CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL:
				case CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL:
					if (flowInfo.isDefinitelyNonNull(local)) {
						if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNonNull(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(local, expression);
							}
						}
						continue;

						switch(this.nullCheckTypes[i] & CONTEXT_MASK) {
							case FlowContext.IN_COMPARISON_NULL:
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variableNullReference(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableRedundantCheckOnNull(local, expression);
								}
								continue;
							case FlowContext.IN_COMPARISON_NON_NULL:
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variableNullReference(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNullComparedToNonNull(local, expression);
								}
								continue;
							case FlowContext.IN_ASSIGNMENT:
								scope.problemReporter().variableRedundantNullAssignment(local, expression);
								continue;
							case FlowContext.IN_INSTANCEOF:
								scope.problemReporter().variableNullInstanceof(local, expression);
								continue;
						}
					} else if (flowInfo.isPotentiallyNull(local)) {

							case FlowContext.IN_COMPARISON_NULL:
								this.nullReferences[i] = null;
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variablePotentialNullReference(local, expression);
									continue;
								}
								break;
							case FlowContext.IN_COMPARISON_NON_NULL:
								this.nullReferences[i] = null;
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variablePotentialNullReference(local, expression);
									continue;
								}
								break;

					break;
				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						scope.problemReporter().variableNullReference(local, expression);
						continue;
					}
					if (flowInfo.isPotentiallyNull(local)) {
						scope.problemReporter().variablePotentialNullReference(local, expression);
					}
					break;
				default:

		return true;
	}

	public void recordUsingNullReference(Scope scope, VariableBinding local,
			Expression reference, int checkType, FlowInfo flowInfo) {
		if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0 && !flowInfo.isDefinitelyUnknown(local))	{
			if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative

						if (flowInfo.cannotBeNull(local)) {
							if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableRedundantCheckOnNonNull(local, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
									flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
								}
							} else if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL)) {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNonNullComparedToNull(local, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
									flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);

							switch(checkType & CONTEXT_MASK) {
								case FlowContext.IN_COMPARISON_NULL:
									if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
										scope.problemReporter().variableNullReference(local, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().variableRedundantCheckOnNull(local, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
										flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);

									return;
								case FlowContext.IN_COMPARISON_NON_NULL:
									if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
										scope.problemReporter().variableNullReference(local, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().variableNullComparedToNonNull(local, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
										flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
									}
									return;
								case FlowContext.IN_ASSIGNMENT:
									scope.problemReporter().variableRedundantNullAssignment(local, reference);
									return;
								case FlowContext.IN_INSTANCEOF:
									scope.problemReporter().variableNullInstanceof(local, reference);
									return;
							}
						} else if (flowInfo.isPotentiallyNull(local)) {
							switch(checkType & CONTEXT_MASK) {
								case FlowContext.IN_COMPARISON_NULL:
									if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
										scope.problemReporter().variablePotentialNullReference(local, reference);
										return;
									}
									break;
								case FlowContext.IN_COMPARISON_NON_NULL:
									if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
										scope.problemReporter().variablePotentialNullReference(local, reference);
										return;
									}
									break;

							return;
						}
						if (flowInfo.canOnlyBeNull(local)) {
							scope.problemReporter().variableNullReference(local, reference);
							return;
						}
						break;

						if (flowInfo.isDefinitelyNonNull(local)) {
							if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableRedundantCheckOnNonNull(local, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
									flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
								}
							} else {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNonNullComparedToNull(local, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
									flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);

							switch(checkType & CONTEXT_MASK) {
								case FlowContext.IN_COMPARISON_NULL:
									if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
										scope.problemReporter().variableNullReference(local, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().variableRedundantCheckOnNull(local, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
										flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);

									return;
								case FlowContext.IN_COMPARISON_NON_NULL:
									if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
										scope.problemReporter().variableNullReference(local, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().variableNullComparedToNonNull(local, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
										flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
									}
									return;
								case FlowContext.IN_ASSIGNMENT:
									scope.problemReporter().variableRedundantNullAssignment(local, reference);
									return;
								case FlowContext.IN_INSTANCEOF:
									scope.problemReporter().variableNullInstanceof(local, reference);
									return;
							}
						} else if (flowInfo.isPotentiallyNull(local)) {
							switch(checkType & CONTEXT_MASK) {
								case FlowContext.IN_COMPARISON_NULL:
									if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
										scope.problemReporter().variablePotentialNullReference(local, reference);
										return;
									}
									break;
								case FlowContext.IN_COMPARISON_NON_NULL:
									if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
										scope.problemReporter().variablePotentialNullReference(local, reference);
										return;
									}
									break;

						break;
					case MAY_NULL :
						if (flowInfo.isDefinitelyNull(local)) {
							scope.problemReporter().variableNullReference(local, reference);
							return;
						}
						if (flowInfo.isPotentiallyNull(local)) {
							scope.problemReporter().variablePotentialNullReference(local, reference);
							return;
						}
						if (flowInfo.isDefinitelyNonNull(local)) {

		}
	}

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

			this.nullCheckTypes = new int[newLength], 0,
			this.nullCount);
	}
	this.nullVariables[this.nullCount] = local;
	this.nullReferences[this.nullCount] = expression;
	this.nullCheckTypes[this.nullCount++] = status;
}




import org.eclipse.jdt.internal.compiler.codegen.BranchLabel;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;

 *      combined with a context indicator (one of {@link #IN_COMPARISON_NULL},
 *      {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})
 */
protected void recordNullReference(VariableBinding local,
	Expression expression, int status) {
	// default implementation: do nothing
}

 *  	be known at the time of calling this method (they are influenced by
 * 		code that follows the current point)
 */
public void recordUsingNullReference(Scope scope, VariableBinding local,
		Expression reference, int checkType, FlowInfo flowInfo) {
	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 ||
			flowInfo.isDefinitelyUnknown(local)) {

			if (flowInfo.isDefinitelyNonNull(local)) {
				if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableRedundantCheckOnNonNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableNonNullComparedToNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);

				switch(checkType & CONTEXT_MASK) {
					case FlowContext.IN_COMPARISON_NULL:
						if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
							scope.problemReporter().variableNullReference(local, reference);
							return;
						}
						if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
							scope.problemReporter().variableRedundantCheckOnNull(local, reference);
						}
						if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
							flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);

						return;
					case FlowContext.IN_COMPARISON_NON_NULL:
						if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
							scope.problemReporter().variableNullReference(local, reference);
							return;
						}
						if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
							scope.problemReporter().variableNullComparedToNonNull(local, reference);
						}
						if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
							flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
						}
						return;
					case FlowContext.IN_ASSIGNMENT:
						scope.problemReporter().variableRedundantNullAssignment(local, reference);
						return;
					case FlowContext.IN_INSTANCEOF:
						scope.problemReporter().variableNullInstanceof(local, reference);
						return;
				}
			} else if (flowInfo.isPotentiallyNull(local)) {
				switch(checkType & CONTEXT_MASK) {
					case FlowContext.IN_COMPARISON_NULL:
						if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
							scope.problemReporter().variablePotentialNullReference(local, reference);
							return;
						}
						break;
					case FlowContext.IN_COMPARISON_NON_NULL:
						if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
							scope.problemReporter().variablePotentialNullReference(local, reference);
							return;
						}
						break;

			break;
		case MAY_NULL :
			if (flowInfo.isDefinitelyNull(local)) {
				scope.problemReporter().variableNullReference(local, reference);
				return;
			}
			if (flowInfo.isPotentiallyNull(local)) {
				scope.problemReporter().variablePotentialNullReference(local, reference);
				return;
			}
			break;




import org.eclipse.jdt.internal.compiler.ast.IfStatement;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;

public abstract class FlowInfo {


	}

/**
 * Check whether a given field or local variable is known to be unable to gain a definite
 * non null or definite null status by the use of an enclosing flow info. The
 * semantics are that if the current flow info marks the variable as potentially
 * unknown or else as being both potentially null and potentially non null,
 * then it won't ever be promoted as definitely null or definitely non null. (It
 * could still get promoted to definite unknown).
 * @param binding the field or local variable to check
 * @return true iff this flow info prevents field or local from being promoted to
 *         definite non null or definite null against an enclosing flow info
 */
public boolean cannotBeDefinitelyNullOrNonNull(VariableBinding binding) {
	return isPotentiallyUnknown(binding) ||
		isPotentiallyNonNull(binding) && isPotentiallyNull(binding);
}

/**
 * Check whether a given field or local variable is known to be non null, either because
 * it is definitely non null, or because is has been tested against non null.
 * @param binding the field or local to check
 * @return true iff field or local cannot be null for this flow info
 */
public boolean cannotBeNull(VariableBinding binding) {
	return isDefinitelyNonNull(binding) || isProtectedNonNull(binding);
}

/**
 * Check whether a given field or local variable is known to be null, either because it
 * is definitely null, or because is has been tested against null. Note that for fields, 
 * this method only takes compile time analysis into account and there's no 
 * guarantee of the field being definitely null during runtime
 * since it can be modified in some other thread.
 * @param binding the field or local to check
 * @return true iff field or local can only be null for this flow info
 */
public boolean canOnlyBeNull(VariableBinding binding) {
	return isDefinitelyNull(binding) || isProtectedNull(binding);
}

/**

	public abstract boolean isDefinitelyAssigned(LocalVariableBinding local);

/**
 * Check status of definite non-null value for a given field or local variable. Note that for fields, this method only
 * takes compile time analysis into account and there's no guarantee of the field being definitely non null during runtime
 * since it can be modified in some other thread.
 * @param binding the field or local to check
 * @return true iff field or local is definitely non null for this flow info
 */
	public abstract boolean isDefinitelyNonNull(VariableBinding binding);

/**
 * Check status of definite null value for a given field or local variable. Note that for fields, this method only
 * takes compile time analysis into account and there's no guarantee of the field being definitely null during runtime
 * since it can be modified in some other thread.
 * @param binding the field or local to check
 * @return true iff field or local is definitely null for this flow info
 */
public abstract boolean isDefinitelyNull(VariableBinding binding);

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

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

	 abstract public boolean isPotentiallyAssigned(LocalVariableBinding field);

/**
 * Check status of potential null assignment for a field or local. Return true if there
 * is a reasonable expectation that the variable be non null at this point.
 * @param binding VariableBinding - the binding for the checked field or local
 * @return true if there is a reasonable expectation that the field or local be non null at
 * this point
 */
public abstract boolean isPotentiallyNonNull(VariableBinding binding);

/**
 * Check status of potential null assignment for a field or local. Return true if there
 * is a reasonable expectation that the variable be null at this point. This
 * includes the protected null case, so as to augment diagnostics, but does not
 * really check that someone deliberately assigned to null on any specific
 * path
 * @param binding VariableBinding - the binding for the checked field or local
 * @return true if there is a reasonable expectation that the field or local be null at
 * this point
 */
public abstract boolean isPotentiallyNull(VariableBinding binding);

/**
 * Return true if the given field or local may have been assigned to an unknown value.
 * @param binding the field or local to check
 * @return true if the given field or local may have been assigned to an unknown value
 */
public abstract boolean isPotentiallyUnknown(VariableBinding binding);

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

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

/**
 * Record that a field or local variable got checked to be non null.
 * @param binding the checked field or local variable
 */
abstract public void markAsComparedEqualToNonNull(VariableBinding binding);

/**
 * Record that a field or local variable got checked to be null.
 * @param binding the checked field or local variable
 */
abstract public void markAsComparedEqualToNull(VariableBinding binding);

	/**
	 * Record a field got definitely assigned.

	abstract public void markAsDefinitelyAssigned(FieldBinding field);

	/**
	 * Record a field or local got definitely assigned to a non-null value.
	 */
	abstract public void markAsDefinitelyNonNull(VariableBinding binding);

	/**
	 * Record a field or local got definitely assigned to null.
	 */
	abstract public void markAsDefinitelyNull(VariableBinding binding);

	/**
	 * Reset all null-information about a given field or local.
	 */
	abstract public void resetNullInfo(VariableBinding binding);

	/**
	 *  variant of {@link #resetNullInfo(VariableBinding)} for resetting null info for all fields
	 */
	abstract public void resetNullInfoForFields();
	/**
	 * Record a field or local may have got assigned to unknown (set the bit on existing info).
	 */
	abstract public void markPotentiallyUnknownBit(VariableBinding binding);

	/**
	 * Record a field or local may have got assigned to null (set the bit on existing info).
	 */
	abstract public void markPotentiallyNullBit(VariableBinding binding);

	/**
	 * Record a field or local may have got assigned to non-null (set the bit on existing info).
	 */
	abstract public void markPotentiallyNonNullBit(VariableBinding binding);

	/**
	 * Record a local got definitely assigned.

	abstract public void markAsDefinitelyAssigned(LocalVariableBinding local);

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

/**
 * Mark the null status of the given field or local according to the given status
 * @param binding
 * @param nullStatus bitset of FLowInfo.UNKNOWN ... FlowInfo.POTENTIALLY_NON_NULL
 */
public void markNullStatus(VariableBinding binding, int nullStatus) {
	switch(nullStatus) {
		// definite status?
		case FlowInfo.UNKNOWN :
			markAsDefinitelyUnknown(binding);
			break;
		case FlowInfo.NULL :
			markAsDefinitelyNull(binding);
			break;
		case FlowInfo.NON_NULL :
			markAsDefinitelyNonNull(binding);
			break;
		default:
			// collect potential status:
			resetNullInfo(binding);
			if ((nullStatus & FlowInfo.POTENTIALLY_UNKNOWN) != 0)
				markPotentiallyUnknownBit(binding);
			if ((nullStatus & FlowInfo.POTENTIALLY_NULL) != 0)
				markPotentiallyNullBit(binding);
			if ((nullStatus & FlowInfo.POTENTIALLY_NON_NULL) != 0)
				markPotentiallyNonNullBit(binding);
			if ((nullStatus & (FlowInfo.POTENTIALLY_NULL|FlowInfo.POTENTIALLY_NON_NULL|FlowInfo.POTENTIALLY_UNKNOWN)) == 0)
				markAsDefinitelyUnknown(binding);
	}
}

/**
 * Answer the null status of the given field or local
 * @param binding
 * @return bitset of FlowInfo.UNKNOWN ... FlowInfo.POTENTIALLY_NON_NULL
 */
public int nullStatus(VariableBinding binding) {
	if (isDefinitelyUnknown(binding))
		return FlowInfo.UNKNOWN;
	if (isDefinitelyNull(binding))
		return FlowInfo.NULL;
	if (isDefinitelyNonNull(binding))
		return FlowInfo.NON_NULL;
	int status = 0;
	if (isPotentiallyUnknown(binding))
		status |= FlowInfo.POTENTIALLY_UNKNOWN;
	if (isPotentiallyNull(binding))
		status |= FlowInfo.POTENTIALLY_NULL;
	if (isPotentiallyNonNull(binding))
		status |= FlowInfo.POTENTIALLY_NON_NULL;
	if (status > 0)
		return status;

 * where this variable is being checked against null
 */
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=303448
abstract public void markedAsNullOrNonNullInAssertExpression(VariableBinding binding);

/** 
 * Returns true if the local variable being checked for was marked as null or not null
 * inside an assert expression due to comparison against null.
 */
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=303448
abstract public boolean isMarkedAsNullOrNonNullInAssertExpression(VariableBinding binding);
}




	VariableBinding finalVariables[];
	int assignCount = 0;

	VariableBinding[] nullVariables;
	Expression[] nullReferences;
	int[] nullCheckTypes;
	int nullCount;

	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) {
		// check only immutable null checks on innermost looping context
		for (int i = 0; i < this.nullCount; i++) {
			VariableBinding local = this.nullVariables[i];
			Expression expression = this.nullReferences[i];
			// final local variable
			switch (this.nullCheckTypes[i]) {

						this.nullReferences[i] = null;
						if (this.nullCheckTypes[i] == (CAN_ONLY_NON_NULL | IN_COMPARISON_NON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNonNull(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(local, expression);
							}
						}
						continue;

						this.nullReferences[i] = null;
						if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNonNull(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(local, expression);
							}
						}
						continue;

						this.nullReferences[i] = null;
						if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNull(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNullComparedToNonNull(local, expression);
							}
						}
						continue;

						switch(this.nullCheckTypes[i] & CONTEXT_MASK) {
							case FlowContext.IN_COMPARISON_NULL:
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variableNullReference(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableRedundantCheckOnNull(local, expression);
								}
								continue;
							case FlowContext.IN_COMPARISON_NON_NULL:
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variableNullReference(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNullComparedToNonNull(local, expression);
								}
								continue;
							case FlowContext.IN_ASSIGNMENT:
								scope.problemReporter().variableRedundantNullAssignment(local, expression);
								continue;
							case FlowContext.IN_INSTANCEOF:
								scope.problemReporter().variableNullInstanceof(local, expression);
								continue;
						}
					} else if (flowInfo.isPotentiallyNull(local)) {

							case FlowContext.IN_COMPARISON_NULL:
								this.nullReferences[i] = null;
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variablePotentialNullReference(local, expression);
									continue;
								}
								break;
							case FlowContext.IN_COMPARISON_NON_NULL:
								this.nullReferences[i] = null;
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variablePotentialNullReference(local, expression);
									continue;
								}
								break;

				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().variableNullReference(local, expression);
						continue;
					}
					break;

		for (int i = 0; i < this.nullCount; i++) {
			Expression expression = this.nullReferences[i];
			// final local variable
			VariableBinding local = this.nullVariables[i];
			switch (this.nullCheckTypes[i]) {
				case CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL:
				case CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL:

						this.nullReferences[i] = null;
						if (this.nullCheckTypes[i] == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableRedundantCheckOnNonNull(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(local, expression);
							}
						}
						continue;

						switch(this.nullCheckTypes[i] & CONTEXT_MASK) {
							case FlowContext.IN_COMPARISON_NULL:
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variableNullReference(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableRedundantCheckOnNull(local, expression);
								}
								continue;
							case FlowContext.IN_COMPARISON_NON_NULL:
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variableNullReference(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNullComparedToNonNull(local, expression);
								}
								continue;
							case FlowContext.IN_ASSIGNMENT:
								scope.problemReporter().variableRedundantNullAssignment(local, expression);
								continue;
							case FlowContext.IN_INSTANCEOF:
								scope.problemReporter().variableNullInstanceof(local, expression);
								continue;
						}
					} else if (flowInfo.isPotentiallyNull(local)) {

							case FlowContext.IN_COMPARISON_NULL:
								this.nullReferences[i] = null;
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variablePotentialNullReference(local, expression);
									continue;
								}
								break;
							case FlowContext.IN_COMPARISON_NON_NULL:
								this.nullReferences[i] = null;
								if (((this.nullCheckTypes[i] & CHECK_MASK) == CAN_ONLY_NULL) && (expression.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
									scope.problemReporter().variablePotentialNullReference(local, expression);
									continue;
								}
								break;

				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().variableNullReference(local, expression);
						continue;
					}
					if (flowInfo.isPotentiallyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().variablePotentialNullReference(local, expression);
						continue;
					}
					break;

		return true;
	}

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

public void recordUsingNullReference(Scope scope, VariableBinding local,
		Expression reference, int checkType, FlowInfo flowInfo) {
	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 ||
			flowInfo.isDefinitelyUnknown(local)) {

			if (flowInfo.isDefinitelyNonNull(local)) {
				if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableRedundantCheckOnNonNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableNonNullComparedToNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);

			} else if (flowInfo.isDefinitelyNull(local)) {
				if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL)) {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableRedundantCheckOnNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableNullComparedToNonNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
					}
				}
			} else if (this.upstreamNullFlowInfo.isDefinitelyNonNull(local) && !flowInfo.isPotentiallyNull(local)) {    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=291418
				flowInfo.markAsDefinitelyNonNull(local );
				if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
					recordNullReference(local, reference, checkType);
				}

				switch(checkType & CONTEXT_MASK) {
					case FlowContext.IN_COMPARISON_NULL:
						if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
							scope.problemReporter().variableNullReference(local, reference);
							return;
						}
						if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
							scope.problemReporter().variableRedundantCheckOnNull(local, reference);
						}
						if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
							flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);

						return;
					case FlowContext.IN_COMPARISON_NON_NULL:
						if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
							scope.problemReporter().variableNullReference(local, reference);
							return;
						}
						if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
							scope.problemReporter().variableNullComparedToNonNull(local, reference);
						}
						if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
							flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
						}
						return;
					case FlowContext.IN_ASSIGNMENT:
						scope.problemReporter().variableRedundantNullAssignment(local, reference);
						return;
					case FlowContext.IN_INSTANCEOF:
						scope.problemReporter().variableNullInstanceof(local, reference);
						return;
				}
			} else if (flowInfo.isPotentiallyNull(local)) {
				switch(checkType & CONTEXT_MASK) {
					case FlowContext.IN_COMPARISON_NULL:
						if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
							scope.problemReporter().variablePotentialNullReference(local, reference);
							return;
						}
						break;
					case FlowContext.IN_COMPARISON_NON_NULL:
						if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
							scope.problemReporter().variablePotentialNullReference(local, reference);
							return;
						}
						break;

				return;
			}
			if (flowInfo.isDefinitelyNull(local)) {
				scope.problemReporter().variableNullReference(local, reference);
				return;
			}
			if (flowInfo.isPotentiallyNull(local)) {
				scope.problemReporter().variablePotentialNullReference(local, reference);
				return;
			}
			recordNullReference(local, reference, checkType);




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

import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;

/**
 * A degenerate form of UnconditionalFlowInfo explicitly meant to capture

	return this;
}

public void markAsComparedEqualToNonNull(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	int position;
    	if (local instanceof FieldBinding) {
			position = local.id;
		} else {
			position = local.id + this.maxFieldCount;
		}
    	// position is zero-based
    	if (position < BitCacheSize) { // use bits
    		// set protected non null
    		this.nullBit1 |= (1L << position);
    		if (COVERAGE_TEST_FLAG) {

	}
}

public void markAsDefinitelyNonNull(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	int position;
    	// position is zero-based
    	if (local instanceof FieldBinding) {
    		position = local.id;
    	} else {
    		position = local.id + this.maxFieldCount;
    	}
    	if (position < BitCacheSize) { // use bits
    		// set assigned non null
    		this.nullBit3 |= (1L << position);
    		if (COVERAGE_TEST_FLAG) {

}
// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either
// PREMATURE project protected non null onto something else
public void markAsDefinitelyNull(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	int position;
    	if (local instanceof FieldBinding) {
    		position = local.id;
    	} else {
    		position = local.id + this.maxFieldCount;
    	}
    	// position is zero-based
    	if (position < BitCacheSize) { // use bits
    		// set assigned null
    		this.nullBit2 |= (1L << position);
    		if (COVERAGE_TEST_FLAG) {

	}
}

public void markAsDefinitelyUnknown(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	int position;
    	if (local instanceof FieldBinding) {
    		position = local.id;
    	} else {
    		position = local.id + this.maxFieldCount;
    	}
    	// position is zero-based
    	if (position < BitCacheSize) { // use bits
    		// set assigned unknown
    		this.nullBit4 |= (1L << position);
    		if (COVERAGE_TEST_FLAG) {

 * Mark a local as potentially having been assigned to an unknown value.
 * @param local the local to mark
 */
public void markPotentiallyUnknownBit(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;

	}
}

public void markPotentiallyNullBit(VariableBinding local) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;

	}
}

public void markPotentiallyNonNullBit(VariableBinding local) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;




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

/**
 * Record initialization status during definite assignment analysis

	return this;
}

final public boolean cannotBeDefinitelyNullOrNonNull(VariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) {
		// use bits
		return (
			(~this.nullBit1

		    & (1L << (position % BitCacheSize))) != 0;
}

final public boolean cannotBeNull(VariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) {
		// use bits
		return (this.nullBit1 & this.nullBit3
			& ((this.nullBit2 & this.nullBit4) | ~this.nullBit2)

		    & (1L << (position % BitCacheSize))) != 0;
}

final public boolean canOnlyBeNull(VariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) {
		// use bits
		return (this.nullBit1 & this.nullBit2
			& (~this.nullBit3 | ~this.nullBit4)

	return isDefinitelyAssigned(local.id + this.maxFieldCount);
}

final public boolean isDefinitelyNonNull(VariableBinding local) {
	if (local instanceof FieldBinding && (this.tagBits & NULL_FLAG_MASK) == 0) {
		// no local yet in scope. Came here because of a field being queried for non null
		// will only happen for final fields, since they are assigned in a constructor or static block
		// and we may currently be in some other method
		this.tagBits |= NULL_FLAG_MASK;
	}
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 ||
			(this.tagBits & NULL_FLAG_MASK) == 0) {

			local.constant() != Constant.NotAConstant) { // String instances
		return true;
	}
	int position;
	if (local instanceof FieldBinding) {
		if (local.isFinal() && ((FieldBinding)local).isStatic()) {
			// static final field's null status may not be in the flow info
			return (((FieldBinding) local).getNullStatusForStaticFinalField() == FlowInfo.NON_NULL);
		}
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) { // use bits
		return ((this.nullBit1 & this.nullBit3 & (~this.nullBit2 | this.nullBit4))
			    & (1L << position)) != 0;

		    & (1L << (position % BitCacheSize))) != 0;
}

final public boolean isDefinitelyNull(VariableBinding local) {
	if (local instanceof FieldBinding && (this.tagBits & NULL_FLAG_MASK) == 0) {
		// no local yet in scope. Came here because of a field being queried for non null
		// will only happen for final fields, since they are assigned in a constructor or static block
		// and we may currently be in some other method
		this.tagBits |= NULL_FLAG_MASK;
	}
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 ||
			(this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		if (local.isFinal() && ((FieldBinding)local).isStatic()) {
			// static final field's null status may not be in the flow info
			return (((FieldBinding) local).getNullStatusForStaticFinalField() == FlowInfo.NULL);
		}
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) { // use bits
		return ((this.nullBit1 & this.nullBit2
			        & (~this.nullBit3 | ~this.nullBit4))

		    & (1L << (position % BitCacheSize))) != 0;
}

final public boolean isDefinitelyUnknown(VariableBinding local) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 ||
			(this.tagBits & NULL_FLAG_MASK) == 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) { // use bits
		return ((this.nullBit1 & this.nullBit4
				& ~this.nullBit2 & ~this.nullBit3) & (1L << position)) != 0;

	return isPotentiallyAssigned(local.id + this.maxFieldCount);
}

final public boolean isPotentiallyNonNull(VariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) { // use bits
		// use bits
		return ((this.nullBit3 & (~this.nullBit1 | ~this.nullBit2))
			    & (1L << position)) != 0;

		    & (1L << (position % BitCacheSize))) != 0;
}

final public boolean isPotentiallyNull(VariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		if (local.isFinal() && ((FieldBinding)local).isStatic()) {
			// static final field's null status may not be in the flow info
			return (((FieldBinding) local).getNullStatusForStaticFinalField() == FlowInfo.POTENTIALLY_NULL);
		}
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) {
		// use bits
		return ((this.nullBit2 & (~this.nullBit1 | ~this.nullBit3))
			    & (1L << position)) != 0;

		    & (1L << (position % BitCacheSize))) != 0;
}

final public boolean isPotentiallyUnknown(VariableBinding local) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 ||
			(this.tagBits & NULL_FLAG_MASK) == 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) { // use bits
		return (this.nullBit4
			& (~this.nullBit1 | ~this.nullBit2 & ~this.nullBit3)

		    & (1L << (position % BitCacheSize))) != 0;
}

final public boolean isProtectedNonNull(VariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) { // use bits
		return (this.nullBit1 & this.nullBit3 & this.nullBit4 & (1L << position)) != 0;
	}
	// use extra vector

		    & (1L << (position % BitCacheSize))) != 0;
}

final public boolean isProtectedNull(VariableBinding local) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(local.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	if (position < BitCacheSize) {
		// use bits
		return (this.nullBit1 & this.nullBit2
			& (this.nullBit3 ^ this.nullBit4)

		throw new AssertionFailedException("assertion failed: " + message); //$NON-NLS-1$
	return expression;
}
public void markAsComparedEqualToNonNull(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		int position;
		if (local instanceof FieldBinding) {
			this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL);
			return;
		} else {
			position = local.id + this.maxFieldCount;
		}
		long mask;
		long a1, a2, a3, a4, na2;
		// position is zero-based
		if (position < BitCacheSize) {
			// use bits
			if (((mask = 1L << position)
				& (a1 = this.nullBit1)

	}
}

public void markAsComparedEqualToNull(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		int position;
		long mask;
		// position is zero-based
		if (local instanceof FieldBinding) {
			this.markNullStatus(local, FlowInfo.POTENTIALLY_NULL);
			return;
		} else {
			position = local.id + this.maxFieldCount;
		}
		if (position < BitCacheSize) {
			// use bits
			if (((mask = 1L << position) & this.nullBit1) != 0) {
  			  	if ((mask

		markAsDefinitelyAssigned(local.id + this.maxFieldCount);
}

public void markAsDefinitelyNonNull(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	long mask;
    	int position;
    	if (local instanceof FieldBinding) {
    		this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL);
    		return;
    	} else {
    		position = local.id + this.maxFieldCount;
    	}
    	// position is zero-based
    	if (position < BitCacheSize) { // use bits
    		// set assigned non null
    		this.nullBit1 |= (mask = 1L << position);
    		this.nullBit3 |= mask;

    	}
    	else {
    		// use extra vector
    		int vectorIndex = (position / BitCacheSize) - 1;
    		if (this.extra == null) {
    			int length = vectorIndex + 1;
    			this.extra = new long[extraLength][];
    			for (int j = 0; j < extraLength; j++) {
    				this.extra[j] = new long[length];
    			}
    		}
    		else {
    			int oldLength; // might need to grow the arrays
    			if (vectorIndex >= (oldLength = this.extra[0].length)) {
    				for (int j = 0; j < extraLength; j++) {
    					System.arraycopy(this.extra[j], 0,
    						(this.extra[j] = new long[vectorIndex + 1]), 0,
    						oldLength);
    				}
    			}
    		}
    		this.extra[2][vectorIndex]
    		    |= (mask = 1L << (position % BitCacheSize));
    		this.extra[4][vectorIndex] |= mask;
    		this.extra[3][vectorIndex] &= (mask = ~mask);

	}
}

public void markAsDefinitelyNull(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	long mask;
    	int position;
    	if (local instanceof FieldBinding) {
    		this.markNullStatus(local, FlowInfo.POTENTIALLY_NULL);
    		return;
    	} else {
    		position = local.id + this.maxFieldCount;
    	}
    	// position is zero-based
    	if (position < BitCacheSize) { // use bits
    		// mark assigned null
    		this.nullBit1 |= (mask = 1L << position);
    		this.nullBit2 |= mask;

    	}
    	else {
    		// use extra vector
    		int vectorIndex = (position / BitCacheSize) - 1;
    		if (this.extra == null) {
    			int length = vectorIndex + 1;
    			this.extra = new long[extraLength][];
    			for (int j = 0; j < extraLength; j++) {
    				this.extra[j] = new long[length];
    			}
    		}
    		else {
    			int oldLength; // might need to grow the arrays
    			if (vectorIndex >= (oldLength = this.extra[0].length)) {
    				for (int j = 0; j < extraLength; j++) {
    					System.arraycopy(this.extra[j], 0,
    						(this.extra[j] = new long[vectorIndex + 1]), 0,
    						oldLength);
    				}
    			}
    		}
    		this.extra[2][vectorIndex]
    		    |= (mask = 1L << (position % BitCacheSize));
    		this.extra[3][vectorIndex] |= mask;
    		this.extra[4][vectorIndex] &= (mask = ~mask);

 */
// PREMATURE may try to get closer to markAsDefinitelyAssigned, but not
//			 obvious
public void markAsDefinitelyUnknown(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		long mask;
		int position;
		if (local instanceof FieldBinding) {
			position = local.id;
		} else {
			position = local.id + this.maxFieldCount;
		}
		// position is zero-based
		if (position < BitCacheSize) {
			// use bits
			// mark assigned null
			this.nullBit1 |= (mask = 1L << position);

		}
		else {
			// use extra vector
			int vectorIndex = (position / BitCacheSize) - 1;
			if (this.extra == null) {
				int length = vectorIndex + 1;
				this.extra = new long[extraLength][];
				for (int j = 0; j < extraLength; j++) {
					this.extra[j] = new long[length];
				}
			}
			else {
				int oldLength; // might need to grow the arrays
				if (vectorIndex >= (oldLength = this.extra[0].length)) {
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
							(this.extra[j] = new long[vectorIndex + 1]), 0,
							oldLength);
					}
				}
			}
			this.extra[2][vectorIndex]
			    |= (mask = 1L << (position % BitCacheSize));
			this.extra[5][vectorIndex] |= mask;
			this.extra[3][vectorIndex] &= (mask = ~mask);

	}
}

public void resetNullInfo(VariableBinding local) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;
        long mask;
        if (local instanceof FieldBinding) {
        	position = local.id;
        } else {
        	position = local.id + this.maxFieldCount;
        }
        if (position < BitCacheSize) {
            // use bits
            this.nullBit1 &= (mask = ~(1L << position));
            this.nullBit2 &= mask;

    	}
	}
}
public void resetNullInfoForFields() {
	if (this != DEAD_END) {
		long mask;
		if (this.maxFieldCount < BitCacheSize) {
			 // use bits
	        this.nullBit1 &= (mask = -1L << this.maxFieldCount);
	        this.nullBit2 &= mask;
	        this.nullBit3 &= mask;
	        this.nullBit4 &= mask;
		}
		else {
			 this.nullBit1 &= (mask = 0L);
		     this.nullBit2 &= mask;
		     this.nullBit3 &= mask;
		     this.nullBit4 &= mask;
			if (this.extra != null){
				for (int position = BitCacheSize; position < this.maxFieldCount; position++) {
					// use extra vector
				    int vectorIndex = (position / BitCacheSize) - 1;
				    if (vectorIndex >= this.extra[2].length)
						break;   // No null info about fields beyond this point in the extra vector
					this.extra[2][vectorIndex]
					    &= (mask = ~(1L << (position % BitCacheSize)));
					this.extra[3][vectorIndex] &= mask;
					this.extra[4][vectorIndex] &= mask;
					this.extra[5][vectorIndex] &= mask;
				}
			}
		}
	}
}

/**
 * Mark a local as potentially having been assigned to an unknown value.
 * @param local the local to mark
 */
public void markPotentiallyUnknownBit(VariableBinding local) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;
        long mask;
        if (local instanceof FieldBinding) {
        	position = local.id;
        } else {
        	position = local.id + this.maxFieldCount;
        }
        if (position < BitCacheSize) {
            // use bits
        	mask = 1L << position;
        	isTrue((this.nullBit1 & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$

	}
}

public void markPotentiallyNullBit(VariableBinding local) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;
        long mask;
        if (local instanceof FieldBinding) {
        	position = local.id;
        } else {
        	position = local.id + this.maxFieldCount;
        }
        if (position < BitCacheSize) {
            // use bits
        	mask = 1L << position;
        	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$

	}
}

public void markPotentiallyNonNullBit(VariableBinding local) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        int position;
        long mask;
        if (local instanceof FieldBinding) {
        	position = local.id;
        } else {
        	position = local.id + this.maxFieldCount;
        }
        if (position < BitCacheSize) {
            // use bits
        	mask = 1L << position;
        	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$

	return this;
}

public void markedAsNullOrNonNullInAssertExpression(VariableBinding binding) {
	int position;
	if (binding instanceof FieldBinding) {
		position = binding.id;
	} else {
		position = binding.id + this.maxFieldCount;
	}
	int oldLength;
	if (this.nullStatusChangedInAssert == null) {
		this.nullStatusChangedInAssert = new int[position + 1];

	this.nullStatusChangedInAssert[position] = 1;
}

public boolean isMarkedAsNullOrNonNullInAssertExpression(VariableBinding binding) {
	int position;
	if (binding instanceof FieldBinding) {
		position = binding.id;
	} else {
		position = binding.id + this.maxFieldCount;
	}
	if(this.nullStatusChangedInAssert == null || position >= this.nullStatusChangedInAssert.length) {
		return false;
	}




/*******************************************************************************
 * Copyright (c) 2000, 2011 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 TypeDeclaration referenceContext;
	public TypeReference superTypeReference;
	java.util.ArrayList deferredBoundChecks;
	public int cumulativeFieldCount;   // cumulative field count from all enclosing types, used to build unique field id's for member types.

	public ClassScope(Scope parent, TypeDeclaration context) {
		super(Scope.CLASS_SCOPE, parent);
		this.referenceContext = context;
		this.deferredBoundChecks = null; // initialized if required
		this.cumulativeFieldCount = 0;
	}

	void buildAnonymousTypeBinding(SourceTypeBinding enclosingType, ReferenceBinding supertype) {

		FieldBinding[] fieldBindings = new FieldBinding[count];
		HashtableOfObject knownFieldNames = new HashtableOfObject(count);
		count = 0;
		ClassScope enclosingClass = this.enclosingClassScope();
		if (enclosingClass != null) {
			this.cumulativeFieldCount += enclosingClass.cumulativeFieldCount;
		}
		for (int i = 0; i < size; i++) {
			FieldDeclaration field = fields[i];
			if (field.getKind() == AbstractVariableDeclaration.INITIALIZER) {

				// now this error reporting is moved into the parser itself. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=212713
			} else {
				FieldBinding fieldBinding = new FieldBinding(field, null, field.modifiers | ExtraCompilerModifiers.AccUnresolved, sourceType);
				fieldBinding.id = count + this.cumulativeFieldCount;
				// field's type will be resolved when needed for top level types
				checkAndSetModifiersForField(fieldBinding, field);


		// remove duplicate fields
		if (count != fieldBindings.length)
			System.arraycopy(fieldBindings, 0, fieldBindings = new FieldBinding[count], 0, count);
		this.cumulativeFieldCount += count;
		sourceType.tagBits &= ~(TagBits.AreFieldsSorted|TagBits.AreFieldsComplete); // in case some static imports reached already into this type
		sourceType.setFields(fieldBindings);
	}




import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;

public class FieldBinding extends VariableBinding {
	public ReferenceBinding declaringClass;
	public int compoundUseFlag = 0; // number or accesses via postIncrement or compoundAssignment
	private int nullStatus;
	
protected FieldBinding() {
	super(null, null, 0, null);

public FieldBinding(char[] name, TypeBinding type, int modifiers, ReferenceBinding declaringClass, Constant constant) {
	super(name, type, modifiers, constant);
	this.declaringClass = declaringClass;
	this.nullStatus = FlowInfo.UNKNOWN;
}
// special API used to change field declaring class for runtime visibility check
public FieldBinding(FieldBinding initialFieldBinding, ReferenceBinding declaringClass) {
	super(initialFieldBinding.name, initialFieldBinding.type, initialFieldBinding.modifiers, initialFieldBinding.constant());
	this.declaringClass = declaringClass;
	this.id = initialFieldBinding.id;
	this.nullStatus = FlowInfo.UNKNOWN;
	setAnnotations(initialFieldBinding.getAnnotations());
}
/* API

	}
	return null;
}

public int getNullStatusForStaticFinalField() {
	return this.nullStatus;
}

public void setNullStatusForStaticFinalField(int nullStatusToMark) {
	this.nullStatus = nullStatusToMark;
}
}




/*******************************************************************************
 * Copyright (c) 2000, 2011 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

	char[] fileName;
	char[] constantPoolName;
	char[] signature;
//	int cumulativeFieldCount;

	private SimpleLookupTable compatibleCache;


public FieldBinding[] unResolvedFields() {
	return Binding.NO_FIELDS;
}

//public int findCumulativeFieldCount() {
//	FieldBinding[] unResolvedFields = this.unResolvedFields();
//	if (unResolvedFields != null) {
//		this.cumulativeFieldCount += unResolvedFields.length;
//	}
//	ReferenceBinding superClassBinding = this.superclass();
//	if (superClassBinding != null) {
//		this.cumulativeFieldCount += superClassBinding.cumulativeFieldCount;
//	}
//	ReferenceBinding[] superInterfacesBinding = this.superInterfaces;
//	return this.cumulativeFieldCount;
//}
}




import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
import org.eclipse.jdt.internal.compiler.parser.JavadocTagConstants;
import org.eclipse.jdt.internal.compiler.parser.Parser;

			return CompilerOptions.VarargsArgumentNeedCast;

		case IProblem.NullLocalVariableReference:
		case IProblem.NullFieldReference:
			return CompilerOptions.NullReference;

		case IProblem.PotentialNullLocalVariableReference:
		case IProblem.PotentialNullFieldReference:
			return CompilerOptions.PotentialNullReference;

		case IProblem.RedundantLocalVariableNullAssignment:
		case IProblem.RedundantFieldNullAssignment:
		case IProblem.RedundantNullCheckOnNonNullLocalVariable:
		case IProblem.RedundantNullCheckOnNullLocalVariable:
		case IProblem.NonNullLocalVariableComparisonYieldsFalse:
		case IProblem.NullLocalVariableComparisonYieldsFalse:
		case IProblem.NullLocalVariableInstanceofYieldsFalse:
		case IProblem.NullFieldInstanceofYieldsFalse:
		case IProblem.RedundantNullCheckOnNonNullField:
		case IProblem.RedundantNullCheckOnNullField:
		case IProblem.NonNullFieldComparisonYieldsFalse:
		case IProblem.NullFieldComparisonYieldsFalse:
			return CompilerOptions.RedundantNullCheck;

		case IProblem.BoxingConversion :

	}
}

public void variableNonNullComparedToNull(VariableBinding variable, ASTNode location) {
	int problem;
	if (variable instanceof FieldBinding) {
		problem = IProblem.NonNullFieldComparisonYieldsFalse;
	} else {
		problem = IProblem.NonNullLocalVariableComparisonYieldsFalse;
	}
	int severity = computeSeverity(problem);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(variable.name)  };
	this.handle(
		problem,
		arguments,
		arguments,
		severity,
		nodeSourceStart(variable, location),
		nodeSourceEnd(variable, location));
}

public void variableNullComparedToNonNull(VariableBinding variable, ASTNode location) {
	int problem;
	if (variable instanceof FieldBinding) {
		problem = IProblem.NullFieldComparisonYieldsFalse;
	} else {
		problem = IProblem.NullLocalVariableComparisonYieldsFalse;
	}
	int severity = computeSeverity(problem);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(variable.name)  };
	this.handle(
		problem,
		arguments,
		arguments,
		severity,
		nodeSourceStart(variable, location),
		nodeSourceEnd(variable, location));
}

public void variableNullInstanceof(VariableBinding variable, ASTNode location) {
	int problem;
	if (variable instanceof FieldBinding) {
		problem = IProblem.NullFieldInstanceofYieldsFalse;
	} else {
		problem = IProblem.NullLocalVariableInstanceofYieldsFalse;
	}
	int severity = computeSeverity(problem);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(variable.name)  };
	this.handle(
		problem,
		arguments,
		arguments,
		severity,
		nodeSourceStart(variable, location),
		nodeSourceEnd(variable, location));
}

public void variableNullReference(VariableBinding variable, ASTNode location) {
	int problem;
	if (variable instanceof FieldBinding) {
		problem = IProblem.NullFieldReference;
	} else {
		problem = IProblem.NullLocalVariableReference;
	}
	int severity = computeSeverity(problem);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(variable.name)  };
	this.handle(
		problem,
		arguments,
		arguments,
		severity,
		nodeSourceStart(variable, location),
		nodeSourceEnd(variable, location));
}

public void variablePotentialNullReference(VariableBinding variable, ASTNode location) {
	int problem;
	if (variable instanceof FieldBinding) {
		problem = IProblem.PotentialNullFieldReference;
	} else {
		problem = IProblem.PotentialNullLocalVariableReference;
	}
	int severity = computeSeverity(problem);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(variable.name)  };
	this.handle(
		problem,
		arguments,
		arguments,
		severity,
		nodeSourceStart(variable, location),
		nodeSourceEnd(variable, location));
}

public void variableRedundantCheckOnNonNull(VariableBinding variable, ASTNode location) {
	int problem;
	if (variable instanceof FieldBinding) {
		problem = IProblem.RedundantNullCheckOnNonNullField;
	} else {
		problem = IProblem.RedundantNullCheckOnNonNullLocalVariable;
	}
	int severity = computeSeverity(problem);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(variable.name)  };
	this.handle(
		problem,
		arguments,
		arguments,
		severity,
		nodeSourceStart(variable, location),
		nodeSourceEnd(variable, location));
}

public void variableRedundantCheckOnNull (VariableBinding variable, ASTNode location) {
	int problem;
	if (variable instanceof FieldBinding) {
		problem = IProblem.RedundantNullCheckOnNullField;
	} else {
		problem = IProblem.RedundantNullCheckOnNullLocalVariable;
	}
	int severity = computeSeverity(problem);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(variable.name)  };
	this.handle(
		problem,
		arguments,
		arguments,
		severity,
		nodeSourceStart(variable, location),
		nodeSourceEnd(variable, location));
}

public void variableRedundantNullAssignment (VariableBinding variable, ASTNode location) {
	int problem;
	if (variable instanceof FieldBinding) {
		problem = IProblem.RedundantFieldNullAssignment;
	} else {
		problem = IProblem.RedundantLocalVariableNullAssignment;
	}
	int severity = computeSeverity(problem);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(variable.name)  };
	this.handle(
		problem,
		arguments,
		arguments,
		severity,
		nodeSourceStart(variable, location),
		nodeSourceEnd(variable, location));
}

public void methodMustOverride(AbstractMethodDeclaration method, long complianceLevel) {




### MORE GENERICS
660 = Unused type arguments for the non generic constructor {0}({1}) of type {2}; it should not be parameterized with arguments <{3}>

### NULL ANALYSIS FOR FIELDS
670 = Null pointer access: The field {0} can only be null at this location
671 = Potential null pointer access: The field {0} may be null at this location
672 = Redundant null check: The field {0} can only be null at this location
673 = Null comparison always yields false: The field {0} can only be null at this location
674 = Redundant null check: The field {0} cannot be null at this location
675 = Null comparison always yields false: The field {0} cannot be null at this location
676 = Redundant assignment: The field {0} can only be null at this location
677 = instanceof always yields false: The field {0} can only be null at this location

### CORRUPTED BINARIES
700 = The class file {0} contains a signature ''{1}'' ill-formed at position {2}


Lines 32-38 Link Here

(-)Eclipse Java Tests Compiler/org/eclipse/jdt/tests/compiler/regression/InitializationTest.java (-1 / +1 lines)
32	// Only the highest compliance level is run; add the VM argument	32	// Only the highest compliance level is run; add the VM argument
33	// -Dcompliance=1.4 (for example) to lower it if needed	33	// -Dcompliance=1.4 (for example) to lower it if needed
34	static {	34	static {
35	// TESTS_NAMES = new String[] { "test011" };	35	TESTS_NAMES = new String[] { "test001" };
36	// TESTS_NUMBERS = new int[] { 204 };	36	// TESTS_NUMBERS = new int[] { 204 };
37	// TESTS_RANGE = new int[] { 231, 240 };	37	// TESTS_RANGE = new int[] { 231, 240 };
38	}	38	}




import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo;
import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo.AssertionFailedException;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;

/**
 * A tests series especially meant to validate the internals of our null

	return copy;
}

public void markAsDefinitelyNonNull(VariableBinding local) {
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	grow(position);
	super.markAsDefinitelyNonNull(local);
}

public void markAsDefinitelyNull(VariableBinding local) {
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	grow(position);
	super.markAsDefinitelyNull(local);
}

public void markAsDefinitelyUnknown(VariableBinding local) {
	int position;
	if (local instanceof FieldBinding) {
		position = local.id;
	} else {
		position = local.id + this.maxFieldCount;
	}
	grow(position);
	super.markAsDefinitelyUnknown(local);
}





// 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[] { "testBug247564h_1" };
//		TESTS_NUMBERS = new int[] { 561 };
//		TESTS_RANGE = new int[] { 1, 2049 };
}

			"    o.toString();\n" +
			"  }\n" +
			"}\n"},
      "----------\n" +
      "1. ERROR in X.java (at line 5)\n" + 
      "	o.toString();\n" + 
      "	^\n" + 
      "Potential null pointer access: The field o may be null at this location\n" + 
      "----------\n"
//      "----------\n"
	);
}


			"    this.o.toString();\n" +
			"  }\n" +
			"}\n"},
        "----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	this.o.toString();\n" + 
		"	     ^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n"
//      "----------\n"
	);
}


			"    o.toString();\n" +
			"  }\n" +
			"}\n"},
        "----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	o.toString();\n" + 
		"	^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n"
//      "----------\n"
	);
}


			"    }\n" +
			"  }\n" +
			"}\n"},
        "----------\n" +
        "1. ERROR in X.java (at line 6)\n" + 
		"	X.this.o.toString();\n" + 
		"	       ^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n"
//      "----------\n"
	);
}


			"  }\n" +
			"  void bar() {/* */}\n" +
			"}\n"},
        "----------\n" +
        "1. ERROR in X.java (at line 5)\n" + 
		"	o.toString();\n" + 
		"	^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n"
//      "----------\n"
	);
}


			"}"},
		"null220");
}

// null analysis -- simple case for field
public void testBug247564a() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  void foo() {\n" +
			"    if (o == null && o.toString() == \"\"){}\n" +
			"    else {}\n" +
			"    o.toString();\n" + // toString() call above defuses null info, so no warning here
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	if (o == null && o.toString() == \"\"){}\n" + 
		"	                 ^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- simple case for field
// no redundant null check warnings should be obtained since value of field
// may be changed in another thread.
public void testBug247564a_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  void foo() {\n" +
			"	 o = null;" +
			"    if (o == null){}\n" +
			"    if (o != null){}\n" +	
			"    o.toString();\n" +	// warn here
			"  }\n" +
			"}\n"},
		"----------\n" +  
		"1. ERROR in X.java (at line 6)\n" + 
		"	o.toString();\n" + 
		"	^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- simple case for field
public void testBug247564a_2() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  void foo() {\n" +
			"    if (o == null){\n" +	// o is null inside the if block
			"		o.toString();\n" +
			"    }\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	o.toString();\n" + 
		"	^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- simple case for field
// null info from one method should not be present in the other (for instance fields)
public void testBug247564a_3() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  void foo() {\n" +
			"  }\n" +
			"  void foo1() {\n" + 
			"	 o.toString();\n" +
			"  }\n" +
			"}\n"},
		""
	);
}

// null analysis -- simple case for static final field
public void testBug247564b() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  static final Object o = null;\n" +
			"  static final Object o1 = new Object();\n" +
			"  void foo() {\n" +
			"    if (o.toString() == \"\") {}\n" +
			"    if (o == null) {}\n" +
			"	 if (o != null) {}\n" +
			"	 if (o1 == null) {}\n" +
			"	 if (o1 != null) {}\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	if (o.toString() == \"\") {}\n" + 
		"	    ^\n" + 
		"Null pointer access: The field o can only be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	if (o == null) {}\n" + 
		"	    ^\n" + 
		"Redundant null check: The field o can only be null at this location\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 7)\n" + 
		"	if (o != null) {}\n" + 
		"	    ^\n" + 
		"Null comparison always yields false: The field o can only be null at this location\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 7)\n" + 
		"	if (o != null) {}\n" + 
		"	               ^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 8)\n" + 
		"	if (o1 == null) {}\n" + 
		"	    ^^\n" + 
		"Null comparison always yields false: The field o1 cannot be null at this location\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 8)\n" + 
		"	if (o1 == null) {}\n" + 
		"	                ^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"7. ERROR in X.java (at line 9)\n" + 
		"	if (o1 != null) {}\n" + 
		"	    ^^\n" + 
		"Redundant null check: The field o1 cannot be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- simple case for static final field
public void testBug247564b_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  static final Object o;\n" +
			"  static final Object o1;\n" +
			"  static {\n" +
			"		o = null;\n" +
			"		o1 = new Object();\n" +
			"  }\n" +
			"  void foo() {\n" +
			"    if (o.toString() == \"\") {}\n" +
			"    if (o == null) {}\n" +
			"	 if (o != null) {}\n" +
			"	 if (o1 == null) {}\n" +
			"	 if (o1 != null) {}\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 9)\n" + 
		"	if (o.toString() == \"\") {}\n" + 
		"	    ^\n" + 
		"Null pointer access: The field o can only be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 10)\n" + 
		"	if (o == null) {}\n" + 
		"	    ^\n" + 
		"Redundant null check: The field o can only be null at this location\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 11)\n" + 
		"	if (o != null) {}\n" + 
		"	    ^\n" + 
		"Null comparison always yields false: The field o can only be null at this location\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 11)\n" + 
		"	if (o != null) {}\n" + 
		"	               ^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 12)\n" + 
		"	if (o1 == null) {}\n" + 
		"	    ^^\n" + 
		"Null comparison always yields false: The field o1 cannot be null at this location\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 12)\n" + 
		"	if (o1 == null) {}\n" + 
		"	                ^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"7. ERROR in X.java (at line 13)\n" + 
		"	if (o1 != null) {}\n" + 
		"	    ^^\n" + 
		"Redundant null check: The field o1 cannot be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- fields in synchronized methods
// check that null analysis for fields in synchronized methods
// behave as it does in ordinary methods.
public void testBug247564c() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  Object o1;\n" +
			"  static final Object o2 = null;\n" +
			"  static final Object o3 = new Object();\n" +
			"  synchronized void foo() {\n" +
			"		o = null;\n" +
			"		if (o == null) {\n" +
			"			o.toString();\n" +
			"		}\n" +
			"		o1 = new Object();\n" +
			"		if (o1 == null) {\n" +
			"			o1.toString();\n" +
			"		}\n" +
			"		if (o2 != null) {\n" +
			"		}\n" +
			"		else {\n" +
			"			o2.toString();\n" +
			"		}\n" +
			"		if (o3 == null) {\n" +
			"		}\n" +
			"		else {\n" +
			"			o3.toString();\n" +
			"		}\n" +
			"  }\n" +
			"  void foo1() {\n" + 
			"	 o.toString();\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 9)\n" + 
		"	o.toString();\n" + 
		"	^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 13)\n" + 
		"	o1.toString();\n" + 
		"	^^\n" + 
		"Potential null pointer access: The field o1 may be null at this location\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 15)\n" + 
		"	if (o2 != null) {\n" + 
		"	    ^^\n" + 
		"Null comparison always yields false: The field o2 can only be null at this location\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 15)\n" + 
		"	if (o2 != null) {\n" + 
		"		}\n" + 
		"	                ^^^^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 18)\n" + 
		"	o2.toString();\n" + 
		"	^^\n" + 
		"Null pointer access: The field o2 can only be null at this location\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 20)\n" + 
		"	if (o3 == null) {\n" + 
		"	    ^^\n" + 
		"Null comparison always yields false: The field o3 cannot be null at this location\n" + 
		"----------\n" + 
		"7. WARNING in X.java (at line 20)\n" + 
		"	if (o3 == null) {\n" + 
		"		}\n" + 
		"	                ^^^^^\n" + 
		"Dead code\n" + 
		"----------\n"
	);
}

// null analysis -- test redundant instanceof warning for static final field
public void testBug247564d() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  static final Object o = null;\n" +
			"  static final Object o1 = new Object();\n" +
			"  void foo() {\n" +
			"    if (o instanceof String) {}\n" +
			"    if (o1 instanceof String) {}\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	if (o instanceof String) {}\n" + 
		"	    ^\n" + 
		"instanceof always yields false: The field o can only be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- test redundant instanceof warning for static final fields
public void testBug247564e_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  static final Object o = null;\n" +
			"  void foo() {\n" +
			"      if (o instanceof X) return;\n" +
			"  }\n" +
			"}"},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	if (o instanceof X) return;\n" + 
		"	    ^\n" + 
		"instanceof always yields false: The field o can only be null at this location\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// null analysis -- test potential null ptr access warning because of static field access through object returned by method call
public void testBug247564f() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		false,
		new String[] {
			"X.java",
			"public class X {\n" +
			"  static Object o;\n" +
			"  static Object o1;\n" +
			"  Object o2;\n" +
			"  X getX() { return new X();\n}\n" +
			"  void foo() {\n" +
			"      if (getX().o == null && this.o.hashCode() == 0) return;\n" +
			"      if (getX().o2 == null && this.o2.hashCode() == 0) return;\n" +
			"  }\n" +
			"}"},
		null,
		compilerOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 8)\n" + 
		"	if (getX().o == null && this.o.hashCode() == 0) return;\n" + 
		"	                             ^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// null analysis -- test potential null ptr access warning because of static field access through object returned by method call
public void testBug247564f_1() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		false,
		new String[] {
			"X.java",
			"public class X {\n" +
			"  static Object o;\n" +
			"  X getX() { return new X();\n}\n" +
			"  Y getY() { return new Y();\n}\n" +
			"  void foo() {\n" +
			"      if (getY().o == null && this.o.hashCode() == 0) return;\n" +
			"      if (getX().o == null && this.o.hashCode() == 0) return;\n" +
			"  }\n" +
			"}\n" +
			"class Y{\n" +
			"	static Object o;\n" +
			"}\n"},
		null,
		compilerOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 9)\n" + 
		"	if (getX().o == null && this.o.hashCode() == 0) return;\n" + 
		"	                             ^\n" + 
		"Potential null pointer access: The field o may be null at this location\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// null analysis -- test field analysis in case of more than 64 fields
public void testBug247564g() {
	Map compilerOptions = getCompilerOptions();
	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
	this.runNegativeTest(
		false,
		new String[] {
			"X.java",
			"public class X {\n" +
			"Object field0, \n" +
			"field1, field2, field3, field4, \n" +
			"field5, field6, field7, field8, \n" +
			"field9, field10, field11, field12, \n" +
			"field13, field14, field15, field16, \n" +
			"field17, field18, field19, field20, \n" +
			"field21, field22, field23, field24, \n" +
			"field25, field26, field27, field28, \n" +
			"field29, field30, field31, field32, \n" +
			"field33, field34, field35, field36, \n" +
			"field37, field38, field39, field40, \n" +
			"field41, field42, field43, field44, \n" +
			"field45, field46, field47, field48, \n" +
			"field49, field50, field51, field52, \n" +
			"field53, field54, field55, field56, \n" +
			"field57, field58, field59, field60, \n" +
			"field61, field62, field63, field64, \n" +
			"field65, field66, field67, field68, \n" +
			"field69, field70, field71, field72, \n" +
			"field73, field74, field75, field76, \n" +
			"field77, field78, field79, field80, \n" +
			"field81, field82, field83, field84, \n" +
			"field85, field86, field87, field88, \n" +
			"field89, field90, field91, field92, \n" +
			"field93, field94, field95, field96, \n" +
			"field97, field98, field99;\n" +
			"static final Object field100 = null;\n" +
			"  void foo() {\n" +
			"	int i = 0;" +
			"   while (i<10){\n" +
			"      i++;\n" +
			"      if (this.field99 == null && this.field99.hashCode() == 0){}\n" +
			"	   this.field98 = null;\n" +
			"	}\n" +
			"	if (this.field98.hashCode() == 0) {}\n" +	// should not complain
			"	this.field97 = null;\n" +
			"	if (this.field97.hashCode() == 0) {}\n" +
			"	if (this.field100.hashCode() == 0) {}\n" +
			"  }\n" +
			"}"},
		null,
		compilerOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 32)\n" + 
		"	if (this.field99 == null && this.field99.hashCode() == 0){}\n" + 
		"	                                 ^^^^^^^\n" + 
		"Potential null pointer access: The field field99 may be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 37)\n" + 
		"	if (this.field97.hashCode() == 0) {}\n" + 
		"	         ^^^^^^^\n" + 
		"Potential null pointer access: The field field97 may be null at this location\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 38)\n" + 
		"	if (this.field100.hashCode() == 0) {}\n" + 
		"	         ^^^^^^^^\n" + 
		"Null pointer access: The field field100 can only be null at this location\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// null analysis -- simple case for field for inner class
// to make sure field id's of inner and outer classes are not same for flow analysis
public void testBug247564h() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  class X1 {\n" +
			"	 Object x;" +
			"	 Object x1;" +
			"	 Object x2;" +
			"	 void goo() {\n" +
			"    	if (o == null && x.toString() == \"\"){}\n" +
			"	 	if (o2 == null && o2.toString() == \"\"){}\n" +
			"	 	if (o2 == null && x2.toString() == \"\"){}\n" +
			"    }\n" +
			
			"  }\n" +
			"  Object o1;\n" +
			"  static Object o2;\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 6)\n" + 
		"	if (o2 == null && o2.toString() == \"\"){}\n" + 
		"	                  ^^\n" + 
		"Potential null pointer access: The field o2 may be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- simple case for field for inner class
// to make sure that id's of local variables in inner classes dotn conflict with those of fields.
public void testBug247564h_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object field0;\n" +
			"  Object field1;\n" +
			"  class X1 {\n" +
			"	 Object field2;" +
			"	 Object field3;" +
			"	 void goo(Object var) {\n" +
			"    	if (var == null && field3.toString() == \"\"){}\n" +
			"    	if (field3 == null && field3.toString() == \"\"){}\n" +
			"    }\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	if (field3 == null && field3.toString() == \"\"){}\n" + 
		"	                      ^^^^^^\n" + 
		"Potential null pointer access: The field field3 may be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- simple case for field for inner class
// to make sure that id's of local variables in inner classes dotn conflict with those of fields.
public void testBug247564h_2() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object field0;\n" +
			"  Object field1;\n" +
			"  class X1 {\n" +
			"	 class X2 {\n" +
			"	 Object field3;\n" +
			"	 void goo(Object var) {\n" +
			"    	if (var == null && field3.toString() == \"\"){}\n" +
			"    	if (field3 == null && field3.toString() == \"\"){}\n" +
			"    	if (field3 == null && field1.toString() == \"\"){}\n" +
			"    }\n" +
			"    }\n" +
			"  Object field2;\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 9)\n" + 
		"	if (field3 == null && field3.toString() == \"\"){}\n" + 
		"	                      ^^^^^^\n" + 
		"Potential null pointer access: The field field3 may be null at this location\n" + 
		"----------\n"
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=332637 
// Dead Code detection removing code that isn't dead
public void testBug332637() {

Return to bug 247564

Lines 1245-1250 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (+20 lines)
1245	/** @since 3.4 */	1245	/** @since 3.4 */
1246	int UnusedTypeArgumentsForConstructorInvocation = MethodRelated + 660;	1246	int UnusedTypeArgumentsForConstructorInvocation = MethodRelated + 660;
1247		1247
		1248	/**
		1249	* Null analysis for fields
		1250	*/
		1251	/** @since 3.7 */
		1252	int NullFieldReference = Internal + FieldRelated + 670;
		1253	/** @since 3.7 */
		1254	int PotentialNullFieldReference = Internal + FieldRelated + 671;
		1255	/** @since 3.7 */
		1256	int RedundantNullCheckOnNullField = Internal + FieldRelated + 672;
		1257	/** @since 3.7 */
		1258	int NullFieldComparisonYieldsFalse = Internal + FieldRelated + 673;
		1259	/** @since 3.7 */
		1260	int RedundantNullCheckOnNonNullField = Internal + FieldRelated + 674;
		1261	/** @since 3.7 */
		1262	int NonNullFieldComparisonYieldsFalse = Internal + FieldRelated + 675;
		1263	/** @since 3.7 */
		1264	int RedundantFieldNullAssignment = Internal + FieldRelated + 676;
		1265	/** @since 3.7 */
		1266	int NullFieldInstanceofYieldsFalse = Internal + FieldRelated + 677;
		1267
1248	/**	1268	/**
1249	* Corrupted binaries	1269	* Corrupted binaries
1250	*/	1270	*/

Lines 807-812 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java (-4 / +12 lines)
807	return null;	807	return null;
808	}	808	}
809		809
		810	public VariableBinding variableBinding() {
		811	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
		812	case Binding.FIELD :
		813	// reading a field
		814	case Binding.LOCAL : // reading a local variable
		815	return (VariableBinding) this.binding;
		816	}
		817	return null;
		818	}
810	public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {	819	public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
811	//If inlinable field, forget the access emulation, the code gen will directly target it	820	//If inlinable field, forget the access emulation, the code gen will directly target it
812	if (((this.bits & ASTNode.DepthMASK) == 0) \|\| (this.constant != Constant.NotAConstant)) {	821	if (((this.bits & ASTNode.DepthMASK) == 0) \|\| (this.constant != Constant.NotAConstant)) {
Lines 859-869 Link Here
859	}	868	}
860	switch (this.bits & ASTNode.RestrictiveFlagMASK) {	869	switch (this.bits & ASTNode.RestrictiveFlagMASK) {
861	case Binding.FIELD : // reading a field	870	case Binding.FIELD : // reading a field
862	return FlowInfo.UNKNOWN;
863	case Binding.LOCAL : // reading a local variable	871	case Binding.LOCAL : // reading a local variable
864	LocalVariableBinding local = (LocalVariableBinding) this.binding;	872	VariableBinding variable = (VariableBinding) this.binding;
865	if (local != null)	873	if (variable != null)
866	return flowInfo.nullStatus(local);	874	return flowInfo.nullStatus(variable);
867	}	875	}
868	return FlowInfo.NON_NULL; // never get there	876	return FlowInfo.NON_NULL; // never get there
869	}	877	}

Lines 103-108 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (-48 / +105 lines)
103	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;	103	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
104	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	104	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
105	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;	105	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
		106	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
106	import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;	107	import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
107	import org.eclipse.jdt.internal.compiler.parser.JavadocTagConstants;	108	import org.eclipse.jdt.internal.compiler.parser.JavadocTagConstants;
108	import org.eclipse.jdt.internal.compiler.parser.Parser;	109	import org.eclipse.jdt.internal.compiler.parser.Parser;
Lines 280-296 Link Here
280	return CompilerOptions.VarargsArgumentNeedCast;	281	return CompilerOptions.VarargsArgumentNeedCast;
281		282
282	case IProblem.NullLocalVariableReference:	283	case IProblem.NullLocalVariableReference:
		284	case IProblem.NullFieldReference:
283	return CompilerOptions.NullReference;	285	return CompilerOptions.NullReference;
284		286
285	case IProblem.PotentialNullLocalVariableReference:	287	case IProblem.PotentialNullLocalVariableReference:
		288	case IProblem.PotentialNullFieldReference:
286	return CompilerOptions.PotentialNullReference;	289	return CompilerOptions.PotentialNullReference;
287		290
288	case IProblem.RedundantLocalVariableNullAssignment:	291	case IProblem.RedundantLocalVariableNullAssignment:
		292	case IProblem.RedundantFieldNullAssignment:
289	case IProblem.RedundantNullCheckOnNonNullLocalVariable:	293	case IProblem.RedundantNullCheckOnNonNullLocalVariable:
290	case IProblem.RedundantNullCheckOnNullLocalVariable:	294	case IProblem.RedundantNullCheckOnNullLocalVariable:
291	case IProblem.NonNullLocalVariableComparisonYieldsFalse:	295	case IProblem.NonNullLocalVariableComparisonYieldsFalse:
292	case IProblem.NullLocalVariableComparisonYieldsFalse:	296	case IProblem.NullLocalVariableComparisonYieldsFalse:
293	case IProblem.NullLocalVariableInstanceofYieldsFalse:	297	case IProblem.NullLocalVariableInstanceofYieldsFalse:
		298	case IProblem.NullFieldInstanceofYieldsFalse:
		299	case IProblem.RedundantNullCheckOnNonNullField:
		300	case IProblem.RedundantNullCheckOnNullField:
		301	case IProblem.NonNullFieldComparisonYieldsFalse:
		302	case IProblem.NullFieldComparisonYieldsFalse:
294	return CompilerOptions.RedundantNullCheck;	303	return CompilerOptions.RedundantNullCheck;
295		304
296	case IProblem.BoxingConversion :	305	case IProblem.BoxingConversion :
Lines 4866-4973 Link Here
4866	}	4875	}
4867	}	4876	}
4868		4877
4869	public void localVariableNonNullComparedToNull(LocalVariableBinding local, ASTNode location) {	4878	public void variableNonNullComparedToNull(VariableBinding variable, ASTNode location) {
4870	int severity = computeSeverity(IProblem.NonNullLocalVariableComparisonYieldsFalse);	4879	int problem;
		4880	if (variable instanceof FieldBinding) {
		4881	problem = IProblem.NonNullFieldComparisonYieldsFalse;
		4882	} else {
		4883	problem = IProblem.NonNullLocalVariableComparisonYieldsFalse;
		4884	}
		4885	int severity = computeSeverity(problem);
4871	if (severity == ProblemSeverities.Ignore) return;	4886	if (severity == ProblemSeverities.Ignore) return;
4872	String[] arguments = new String[] {new String(local.name) };	4887	String[] arguments = new String[] {new String(variable.name) };
4873	this.handle(	4888	this.handle(
4874	IProblem.NonNullLocalVariableComparisonYieldsFalse,	4889	problem,
4875	arguments,	4890	arguments,
4876	arguments,	4891	arguments,
4877	severity,	4892	severity,
4878	nodeSourceStart(local, location),	4893	nodeSourceStart(variable, location),
4879	nodeSourceEnd(local, location));	4894	nodeSourceEnd(variable, location));
4880	}	4895	}
4881		4896
4882	public void localVariableNullComparedToNonNull(LocalVariableBinding local, ASTNode location) {	4897	public void variableNullComparedToNonNull(VariableBinding variable, ASTNode location) {
4883	int severity = computeSeverity(IProblem.NullLocalVariableComparisonYieldsFalse);	4898	int problem;
		4899	if (variable instanceof FieldBinding) {
		4900	problem = IProblem.NullFieldComparisonYieldsFalse;
		4901	} else {
		4902	problem = IProblem.NullLocalVariableComparisonYieldsFalse;
		4903	}
		4904	int severity = computeSeverity(problem);
4884	if (severity == ProblemSeverities.Ignore) return;	4905	if (severity == ProblemSeverities.Ignore) return;
4885	String[] arguments = new String[] {new String(local.name) };	4906	String[] arguments = new String[] {new String(variable.name) };
4886	this.handle(	4907	this.handle(
4887	IProblem.NullLocalVariableComparisonYieldsFalse,	4908	problem,
4888	arguments,	4909	arguments,
4889	arguments,	4910	arguments,
4890	severity,	4911	severity,
4891	nodeSourceStart(local, location),	4912	nodeSourceStart(variable, location),
4892	nodeSourceEnd(local, location));	4913	nodeSourceEnd(variable, location));
4893	}	4914	}
4894		4915
4895	public void localVariableNullInstanceof(LocalVariableBinding local, ASTNode location) {	4916	public void variableNullInstanceof(VariableBinding variable, ASTNode location) {
4896	int severity = computeSeverity(IProblem.NullLocalVariableInstanceofYieldsFalse);	4917	int problem;
		4918	if (variable instanceof FieldBinding) {
		4919	problem = IProblem.NullFieldInstanceofYieldsFalse;
		4920	} else {
		4921	problem = IProblem.NullLocalVariableInstanceofYieldsFalse;
		4922	}
		4923	int severity = computeSeverity(problem);
4897	if (severity == ProblemSeverities.Ignore) return;	4924	if (severity == ProblemSeverities.Ignore) return;
4898	String[] arguments = new String[] {new String(local.name) };	4925	String[] arguments = new String[] {new String(variable.name) };
4899	this.handle(	4926	this.handle(
4900	IProblem.NullLocalVariableInstanceofYieldsFalse,	4927	problem,
4901	arguments,	4928	arguments,
4902	arguments,	4929	arguments,
4903	severity,	4930	severity,
4904	nodeSourceStart(local, location),	4931	nodeSourceStart(variable, location),
4905	nodeSourceEnd(local, location));	4932	nodeSourceEnd(variable, location));
4906	}	4933	}
4907		4934
4908	public void localVariableNullReference(LocalVariableBinding local, ASTNode location) {	4935	public void variableNullReference(VariableBinding variable, ASTNode location) {
4909	int severity = computeSeverity(IProblem.NullLocalVariableReference);	4936	int problem;
		4937	if (variable instanceof FieldBinding) {
		4938	problem = IProblem.NullFieldReference;
		4939	} else {
		4940	problem = IProblem.NullLocalVariableReference;
		4941	}
		4942	int severity = computeSeverity(problem);
4910	if (severity == ProblemSeverities.Ignore) return;	4943	if (severity == ProblemSeverities.Ignore) return;
4911	String[] arguments = new String[] {new String(local.name) };	4944	String[] arguments = new String[] {new String(variable.name) };
4912	this.handle(	4945	this.handle(
4913	IProblem.NullLocalVariableReference,	4946	problem,
4914	arguments,	4947	arguments,
4915	arguments,	4948	arguments,
4916	severity,	4949	severity,
4917	nodeSourceStart(local, location),	4950	nodeSourceStart(variable, location),
4918	nodeSourceEnd(local, location));	4951	nodeSourceEnd(variable, location));
4919	}	4952	}
4920		4953
4921	public void localVariablePotentialNullReference(LocalVariableBinding local, ASTNode location) {	4954	public void variablePotentialNullReference(VariableBinding variable, ASTNode location) {
4922	int severity = computeSeverity(IProblem.PotentialNullLocalVariableReference);	4955	int problem;
		4956	if (variable instanceof FieldBinding) {
		4957	problem = IProblem.PotentialNullFieldReference;
		4958	} else {
		4959	problem = IProblem.PotentialNullLocalVariableReference;
		4960	}
		4961	int severity = computeSeverity(problem);
4923	if (severity == ProblemSeverities.Ignore) return;	4962	if (severity == ProblemSeverities.Ignore) return;
4924	String[] arguments = new String[] {new String(local.name)};	4963	String[] arguments = new String[] {new String(variable.name) };
4925	this.handle(	4964	this.handle(
4926	IProblem.PotentialNullLocalVariableReference,	4965	problem,
4927	arguments,	4966	arguments,
4928	arguments,	4967	arguments,
4929	severity,	4968	severity,
4930	nodeSourceStart(local, location),	4969	nodeSourceStart(variable, location),
4931	nodeSourceEnd(local, location));	4970	nodeSourceEnd(variable, location));
4932	}	4971	}
4933		4972
4934	public void localVariableRedundantCheckOnNonNull(LocalVariableBinding local, ASTNode location) {	4973	public void variableRedundantCheckOnNonNull(VariableBinding variable, ASTNode location) {
4935	int severity = computeSeverity(IProblem.RedundantNullCheckOnNonNullLocalVariable);	4974	int problem;
		4975	if (variable instanceof FieldBinding) {
		4976	problem = IProblem.RedundantNullCheckOnNonNullField;
		4977	} else {
		4978	problem = IProblem.RedundantNullCheckOnNonNullLocalVariable;
		4979	}
		4980	int severity = computeSeverity(problem);
4936	if (severity == ProblemSeverities.Ignore) return;	4981	if (severity == ProblemSeverities.Ignore) return;
4937	String[] arguments = new String[] {new String(local.name) };	4982	String[] arguments = new String[] {new String(variable.name) };
4938	this.handle(	4983	this.handle(
4939	IProblem.RedundantNullCheckOnNonNullLocalVariable,	4984	problem,
4940	arguments,	4985	arguments,
4941	arguments,	4986	arguments,
4942	severity,	4987	severity,
4943	nodeSourceStart(local, location),	4988	nodeSourceStart(variable, location),
4944	nodeSourceEnd(local, location));	4989	nodeSourceEnd(variable, location));
4945	}	4990	}
4946		4991
4947	public void localVariableRedundantCheckOnNull(LocalVariableBinding local, ASTNode location) {	4992	public void variableRedundantCheckOnNull (VariableBinding variable, ASTNode location) {
4948	int severity = computeSeverity(IProblem.RedundantNullCheckOnNullLocalVariable);	4993	int problem;
		4994	if (variable instanceof FieldBinding) {
		4995	problem = IProblem.RedundantNullCheckOnNullField;
		4996	} else {
		4997	problem = IProblem.RedundantNullCheckOnNullLocalVariable;
		4998	}
		4999	int severity = computeSeverity(problem);
4949	if (severity == ProblemSeverities.Ignore) return;	5000	if (severity == ProblemSeverities.Ignore) return;
4950	String[] arguments = new String[] {new String(local.name) };	5001	String[] arguments = new String[] {new String(variable.name) };
4951	this.handle(	5002	this.handle(
4952	IProblem.RedundantNullCheckOnNullLocalVariable,	5003	problem,
4953	arguments,	5004	arguments,
4954	arguments,	5005	arguments,
4955	severity,	5006	severity,
4956	nodeSourceStart(local, location),	5007	nodeSourceStart(variable, location),
4957	nodeSourceEnd(local, location));	5008	nodeSourceEnd(variable, location));
4958	}	5009	}
4959		5010
4960	public void localVariableRedundantNullAssignment(LocalVariableBinding local, ASTNode location) {	5011	public void variableRedundantNullAssignment (VariableBinding variable, ASTNode location) {
4961	int severity = computeSeverity(IProblem.RedundantLocalVariableNullAssignment);	5012	int problem;
		5013	if (variable instanceof FieldBinding) {
		5014	problem = IProblem.RedundantFieldNullAssignment;
		5015	} else {
		5016	problem = IProblem.RedundantLocalVariableNullAssignment;
		5017	}
		5018	int severity = computeSeverity(problem);
4962	if (severity == ProblemSeverities.Ignore) return;	5019	if (severity == ProblemSeverities.Ignore) return;
4963	String[] arguments = new String[] {new String(local.name) };	5020	String[] arguments = new String[] {new String(variable.name) };
4964	this.handle(	5021	this.handle(
4965	IProblem.RedundantLocalVariableNullAssignment,	5022	problem,
4966	arguments,	5023	arguments,
4967	arguments,	5024	arguments,
4968	severity,	5025	severity,
4969	nodeSourceStart(local, location),	5026	nodeSourceStart(variable, location),
4970	nodeSourceEnd(local, location));	5027	nodeSourceEnd(variable, location));
4971	}	5028	}
4972		5029
4973	public void methodMustOverride(AbstractMethodDeclaration method, long complianceLevel) {	5030	public void methodMustOverride(AbstractMethodDeclaration method, long complianceLevel) {

Lines 572-577 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+10 lines)
572	### MORE GENERICS	572	### MORE GENERICS
573	660 = Unused type arguments for the non generic constructor {0}({1}) of type {2}; it should not be parameterized with arguments <{3}>	573	660 = Unused type arguments for the non generic constructor {0}({1}) of type {2}; it should not be parameterized with arguments <{3}>
574		574
		575	### NULL ANALYSIS FOR FIELDS
		576	670 = Null pointer access: The field {0} can only be null at this location
		577	671 = Potential null pointer access: The field {0} may be null at this location
		578	672 = Redundant null check: The field {0} can only be null at this location
		579	673 = Null comparison always yields false: The field {0} can only be null at this location
		580	674 = Redundant null check: The field {0} cannot be null at this location
		581	675 = Null comparison always yields false: The field {0} cannot be null at this location
		582	676 = Redundant assignment: The field {0} can only be null at this location
		583	677 = instanceof always yields false: The field {0} can only be null at this location
		584
575	### CORRUPTED BINARIES	585	### CORRUPTED BINARIES
576	700 = The class file {0} contains a signature ''{1}'' ill-formed at position {2}	586	700 = The class file {0} contains a signature ''{1}'' ill-formed at position {2}
577		587

Lines 24-46 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java (-4 / +4 lines)
24	}	24	}
25	private void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {	25	private void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {
26		26
27	LocalVariableBinding local = this.left.localVariableBinding();	27	VariableBinding local = this.left.variableBinding();
28	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	28	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
29	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.right.nullStatus(flowInfo), this.left);	29	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.right.nullStatus(flowInfo), this.left);
30	}	30	}
31	local = this.right.localVariableBinding();	31	local = this.right.variableBinding();
32	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	32	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
33	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.left.nullStatus(flowInfo), this.right);	33	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.left.nullStatus(flowInfo), this.right);
34	}	34	}
35	}	35	}
36	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, LocalVariableBinding local, int nullStatus, Expression reference) {	36	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, VariableBinding local, int nullStatus, Expression reference) {
37	switch (nullStatus) {	37	switch (nullStatus) {
38	case FlowInfo.NULL :	38	case FlowInfo.NULL :
39	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	39	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
40	flowContext.recordUsingNullReference(scope, local, reference,	40	flowContext.recordUsingNullReference(scope, local, reference,
41	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);	41	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);
42	initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set	42	initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set
43	initsWhenFalse.markAsComparedEqualToNonNull(local); // from thereon it is set	43	initsWhenFalse.markAsComparedEqualToNonNull(local ); // from thereon it is set
44	} else {	44	} else {
45	flowContext.recordUsingNullReference(scope, local, reference,	45	flowContext.recordUsingNullReference(scope, local, reference,
46	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);	46	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);

Lines 31-46 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/InstanceOfExpression.java (-5 / +5 lines)
31	}	31	}
32		32
33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	33	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
34	LocalVariableBinding local = this.expression.localVariableBinding();	34	VariableBinding variable = this.expression.variableBinding();
35	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	35	if (variable != null && (variable.type.tagBits & TagBits.IsBaseType) == 0) {
36	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo).	36	flowInfo = this.expression.analyseCode(currentScope, flowContext, flowInfo).
37	unconditionalInits();	37	unconditionalInits();
38	FlowInfo initsWhenTrue = flowInfo.copy();	38	FlowInfo initsWhenTrue = flowInfo.copy();
39	initsWhenTrue.markAsComparedEqualToNonNull(local);	39	initsWhenTrue.markAsComparedEqualToNonNull(variable );
40	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	40	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
41	initsWhenTrue.markedAsNullOrNonNullInAssertExpression(local);	41	initsWhenTrue.markedAsNullOrNonNullInAssertExpression(variable);
42	}	42	}
43	flowContext.recordUsingNullReference(currentScope, local,	43	flowContext.recordUsingNullReference(currentScope, variable,
44	this.expression, FlowContext.CAN_ONLY_NULL \| FlowContext.IN_INSTANCEOF, flowInfo);	44	this.expression, FlowContext.CAN_ONLY_NULL \| FlowContext.IN_INSTANCEOF, flowInfo);
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());

Lines 11-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/NullInfoRegistry.java (-12 / +33 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.flow;	12	package org.eclipse.jdt.internal.compiler.flow;
13		13
14	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;	14	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
		15	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
15		16
16	/**	17	/**
17	* A degenerate form of UnconditionalFlowInfo explicitly meant to capture	18	* A degenerate form of UnconditionalFlowInfo explicitly meant to capture
Lines 116-128 Link Here
116	return this;	117	return this;
117	}	118	}
118		119
119	public void markAsComparedEqualToNonNull(LocalVariableBinding local) {	120	public void markAsComparedEqualToNonNull(VariableBinding local) {
120	// protected from non-object locals in calling methods	121	// protected from non-object locals in calling methods
121	if (this != DEAD_END) {	122	if (this != DEAD_END) {
122	this.tagBits \|= NULL_FLAG_MASK;	123	this.tagBits \|= NULL_FLAG_MASK;
123	int position;	124	int position;
		125	if (local instanceof FieldBinding) {
		126	position = local.id;
		127	} else {
		128	position = local.id + this.maxFieldCount;
		129	}
124	// position is zero-based	130	// position is zero-based
125	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	131	if (position < BitCacheSize) { // use bits
126	// set protected non null	132	// set protected non null
127	this.nullBit1 \|= (1L << position);	133	this.nullBit1 \|= (1L << position);
128	if (COVERAGE_TEST_FLAG) {	134	if (COVERAGE_TEST_FLAG) {
Lines 161-173 Link Here
161	}	167	}
162	}	168	}
163		169
164	public void markAsDefinitelyNonNull(LocalVariableBinding local) {	170	public void markAsDefinitelyNonNull(VariableBinding local) {
165	// protected from non-object locals in calling methods	171	// protected from non-object locals in calling methods
166	if (this != DEAD_END) {	172	if (this != DEAD_END) {
167	this.tagBits \|= NULL_FLAG_MASK;	173	this.tagBits \|= NULL_FLAG_MASK;
168	int position;	174	int position;
169	// position is zero-based	175	// position is zero-based
170	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	176	if (local instanceof FieldBinding) {
		177	position = local.id;
		178	} else {
		179	position = local.id + this.maxFieldCount;
		180	}
		181	if (position < BitCacheSize) { // use bits
171	// set assigned non null	182	// set assigned non null
172	this.nullBit3 \|= (1L << position);	183	this.nullBit3 \|= (1L << position);
173	if (COVERAGE_TEST_FLAG) {	184	if (COVERAGE_TEST_FLAG) {
Lines 207-219 Link Here
207	}	218	}
208	// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either	219	// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either
209	// PREMATURE project protected non null onto something else	220	// PREMATURE project protected non null onto something else
210	public void markAsDefinitelyNull(LocalVariableBinding local) {	221	public void markAsDefinitelyNull(VariableBinding local) {
211	// protected from non-object locals in calling methods	222	// protected from non-object locals in calling methods
212	if (this != DEAD_END) {	223	if (this != DEAD_END) {
213	this.tagBits \|= NULL_FLAG_MASK;	224	this.tagBits \|= NULL_FLAG_MASK;
214	int position;	225	int position;
		226	if (local instanceof FieldBinding) {
		227	position = local.id;
		228	} else {
		229	position = local.id + this.maxFieldCount;
		230	}
215	// position is zero-based	231	// position is zero-based
216	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	232	if (position < BitCacheSize) { // use bits
217	// set assigned null	233	// set assigned null
218	this.nullBit2 \|= (1L << position);	234	this.nullBit2 \|= (1L << position);
219	if (COVERAGE_TEST_FLAG) {	235	if (COVERAGE_TEST_FLAG) {
Lines 252-264 Link Here
252	}	268	}
253	}	269	}
254		270
255	public void markAsDefinitelyUnknown(LocalVariableBinding local) {	271	public void markAsDefinitelyUnknown(VariableBinding local) {
256	// protected from non-object locals in calling methods	272	// protected from non-object locals in calling methods
257	if (this != DEAD_END) {	273	if (this != DEAD_END) {
258	this.tagBits \|= NULL_FLAG_MASK;	274	this.tagBits \|= NULL_FLAG_MASK;
259	int position;	275	int position;
		276	if (local instanceof FieldBinding) {
		277	position = local.id;
		278	} else {
		279	position = local.id + this.maxFieldCount;
		280	}
260	// position is zero-based	281	// position is zero-based
261	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	282	if (position < BitCacheSize) { // use bits
262	// set assigned unknown	283	// set assigned unknown
263	this.nullBit4 \|= (1L << position);	284	this.nullBit4 \|= (1L << position);
264	if (COVERAGE_TEST_FLAG) {	285	if (COVERAGE_TEST_FLAG) {
Lines 407-413 Link Here
407	* Mark a local as potentially having been assigned to an unknown value.	428	* Mark a local as potentially having been assigned to an unknown value.
408	* @param local the local to mark	429	* @param local the local to mark
409	*/	430	*/
410	public void markPotentiallyUnknownBit(LocalVariableBinding local) {	431	public void markPotentiallyUnknownBit(VariableBinding local) {
411	// protected from non-object locals in calling methods	432	// protected from non-object locals in calling methods
412	if (this != DEAD_END) {	433	if (this != DEAD_END) {
413	this.tagBits \|= NULL_FLAG_MASK;	434	this.tagBits \|= NULL_FLAG_MASK;
Lines 454-460 Link Here
454	}	475	}
455	}	476	}
456		477
457	public void markPotentiallyNullBit(LocalVariableBinding local) {	478	public void markPotentiallyNullBit(VariableBinding local) {
458	if (this != DEAD_END) {	479	if (this != DEAD_END) {
459	this.tagBits \|= NULL_FLAG_MASK;	480	this.tagBits \|= NULL_FLAG_MASK;
460	int position;	481	int position;
Lines 500-506 Link Here
500	}	521	}
501	}	522	}
502		523
503	public void markPotentiallyNonNullBit(LocalVariableBinding local) {	524	public void markPotentiallyNonNullBit(VariableBinding local) {
504	if (this != DEAD_END) {	525	if (this != DEAD_END) {
505	this.tagBits \|= NULL_FLAG_MASK;	526	this.tagBits \|= NULL_FLAG_MASK;
506	int position;	527	int position;

Lines 696-701 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (+16 lines)
696	expectedProblemAttributes.put("NonGenericConstructor", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	696	expectedProblemAttributes.put("NonGenericConstructor", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
697	expectedProblemAttributes.put("NonGenericMethod", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	697	expectedProblemAttributes.put("NonGenericMethod", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
698	expectedProblemAttributes.put("NonGenericType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	698	expectedProblemAttributes.put("NonGenericType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		699	expectedProblemAttributes.put("NonNullFieldComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
699	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	700	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
700	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	701	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
701	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	702	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
Lines 708-713 Link Here
708	expectedProblemAttributes.put("NotVisibleField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	709	expectedProblemAttributes.put("NotVisibleField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
709	expectedProblemAttributes.put("NotVisibleMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	710	expectedProblemAttributes.put("NotVisibleMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
710	expectedProblemAttributes.put("NotVisibleType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	711	expectedProblemAttributes.put("NotVisibleType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		712	expectedProblemAttributes.put("NullFieldComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		713	expectedProblemAttributes.put("NullFieldInstanceofYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		714	expectedProblemAttributes.put("NullFieldReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
711	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	715	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
712	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	716	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
713	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	717	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
Lines 745-750 Link Here
745	expectedProblemAttributes.put("ParsingErrorReplaceTokens", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	749	expectedProblemAttributes.put("ParsingErrorReplaceTokens", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
746	expectedProblemAttributes.put("ParsingErrorUnexpectedEOF", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	750	expectedProblemAttributes.put("ParsingErrorUnexpectedEOF", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
747	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	751	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		752	expectedProblemAttributes.put("PotentialNullFieldReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
748	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	753	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
749	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	754	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
750	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	755	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
Lines 752-759 Link Here
752	expectedProblemAttributes.put("RecursiveConstructorInvocation", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	757	expectedProblemAttributes.put("RecursiveConstructorInvocation", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
753	expectedProblemAttributes.put("RedefinedArgument", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	758	expectedProblemAttributes.put("RedefinedArgument", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
754	expectedProblemAttributes.put("RedefinedLocal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	759	expectedProblemAttributes.put("RedefinedLocal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
		760	expectedProblemAttributes.put("RedundantFieldNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
755	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	761	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		762	expectedProblemAttributes.put("RedundantNullCheckOnNonNullField", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
756	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	763	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		764	expectedProblemAttributes.put("RedundantNullCheckOnNullField", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
757	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	765	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
758	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));	766	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
759	expectedProblemAttributes.put("ReferenceToForwardField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	767	expectedProblemAttributes.put("ReferenceToForwardField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
Lines 1333-1338 Link Here
1333	expectedProblemAttributes.put("NonGenericConstructor", SKIP);	1341	expectedProblemAttributes.put("NonGenericConstructor", SKIP);
1334	expectedProblemAttributes.put("NonGenericMethod", SKIP);	1342	expectedProblemAttributes.put("NonGenericMethod", SKIP);
1335	expectedProblemAttributes.put("NonGenericType", SKIP);	1343	expectedProblemAttributes.put("NonGenericType", SKIP);
		1344	expectedProblemAttributes.put("NonNullFieldComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1336	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1345	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1337	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER));	1346	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER));
1338	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER));	1347	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER));
Lines 1345-1350 Link Here
1345	expectedProblemAttributes.put("NotVisibleField", SKIP);	1354	expectedProblemAttributes.put("NotVisibleField", SKIP);
1346	expectedProblemAttributes.put("NotVisibleMethod", SKIP);	1355	expectedProblemAttributes.put("NotVisibleMethod", SKIP);
1347	expectedProblemAttributes.put("NotVisibleType", SKIP);	1356	expectedProblemAttributes.put("NotVisibleType", SKIP);
		1357	expectedProblemAttributes.put("NullFieldComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		1358	expectedProblemAttributes.put("NullFieldInstanceofYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		1359	expectedProblemAttributes.put("NullFieldReference", new ProblemAttributes(JavaCore.COMPILER_PB_NULL_REFERENCE));
1348	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1360	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1349	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1361	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1350	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_NULL_REFERENCE));	1362	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_NULL_REFERENCE));
Lines 1382-1387 Link Here
1382	expectedProblemAttributes.put("ParsingErrorReplaceTokens", SKIP);	1394	expectedProblemAttributes.put("ParsingErrorReplaceTokens", SKIP);
1383	expectedProblemAttributes.put("ParsingErrorUnexpectedEOF", SKIP);	1395	expectedProblemAttributes.put("ParsingErrorUnexpectedEOF", SKIP);
1384	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT));	1396	expectedProblemAttributes.put("PossibleAccidentalBooleanAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_POSSIBLE_ACCIDENTAL_BOOLEAN_ASSIGNMENT));
		1397	expectedProblemAttributes.put("PotentialNullFieldReference", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE));
1385	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE));	1398	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE));
1386	expectedProblemAttributes.put("PublicClassMustMatchFileName", SKIP);	1399	expectedProblemAttributes.put("PublicClassMustMatchFileName", SKIP);
1387	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", SKIP);	1400	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", SKIP);
Lines 1389-1396 Link Here
1389	expectedProblemAttributes.put("RecursiveConstructorInvocation", SKIP);	1402	expectedProblemAttributes.put("RecursiveConstructorInvocation", SKIP);
1390	expectedProblemAttributes.put("RedefinedArgument", SKIP);	1403	expectedProblemAttributes.put("RedefinedArgument", SKIP);
1391	expectedProblemAttributes.put("RedefinedLocal", SKIP);	1404	expectedProblemAttributes.put("RedefinedLocal", SKIP);
		1405	expectedProblemAttributes.put("RedundantFieldNullAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1392	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1406	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		1407	expectedProblemAttributes.put("RedundantNullCheckOnNonNullField", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1393	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1408	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		1409	expectedProblemAttributes.put("RedundantNullCheckOnNullField", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1394	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1410	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1395	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_SUPERINTERFACE));	1411	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_SUPERINTERFACE));
1396	expectedProblemAttributes.put("ReferenceToForwardField", SKIP);	1412	expectedProblemAttributes.put("ReferenceToForwardField", SKIP);