Attachment #185729 for bug #247564

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




	int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;
	/** @since 3.6 */
	int UnresolvedVariable = FieldRelated + 83;
	
	// variable hiding
	/** @since 3.0 */
	int LocalVariableHidingLocalVariable = Internal + 90;

    /** @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	}

Lines 35-40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java (+8 lines)
35	import org.eclipse.jdt.internal.compiler.lookup.TagBits;	35	import org.eclipse.jdt.internal.compiler.lookup.TagBits;
36	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	36	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
37	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	37	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
		38	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
38		39
39	public class FieldReference extends Reference implements InvocationSite {	40	public class FieldReference extends Reference implements InvocationSite {
40		41
Lines 668-671 Link Here
668	}	669	}
669	visitor.endVisit(this, scope);	670	visitor.endVisit(this, scope);
670	}	671	}
		672
		673	public VariableBinding variableBinding() {
		674	if (this.receiver.isThis() \|\| this.binding.isStatic())
		675	return this.binding;
		676	return super.variableBinding();
		677	}
		678
671	}	679	}




}

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 81-87 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-1 / +1 lines)
81	}	81	}
82	flowInfo.markAsDefinitelyAssigned(this.binding);	82	flowInfo.markAsDefinitelyAssigned(this.binding);
83	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {	83	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {
84	flowInfo.markNullStatus(this.binding, nullStatus);	84	flowInfo.markNullStatus(this.binding, nullStatus );
85	// no need to inform enclosing try block since its locals won't get	85	// no need to inform enclosing try block since its locals won't get
86	// known by the finally block	86	// known by the finally block
87	}	87	}

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 1086-1091 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java (+26 lines)
1086	if (this.maxFieldCount < localMaxFieldCount) {	1086	if (this.maxFieldCount < localMaxFieldCount) {
1087	this.maxFieldCount = localMaxFieldCount;	1087	this.maxFieldCount = localMaxFieldCount;
1088	}	1088	}
		1089
		1090	// field count from supertypes should be included in maxFieldCount,
		1091	// so that a field from supertype doesn't end up with same id as a local variable
		1092	// in a method being analyzed.
		1093	ReferenceBinding superClassBinding = this.binding.superclass;
		1094	while (superClassBinding != null) {
		1095	FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
		1096	if (unResolvedFields != null) {
		1097	this.maxFieldCount += unResolvedFields.length;
		1098	}
		1099	superClassBinding = superClassBinding.superclass();
		1100	}
		1101	ReferenceBinding[] superInterfacesBinding = this.binding.superInterfaces;
		1102	this.maxFieldCount += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		1103
1089	if (needSerialVersion) {	1104	if (needSerialVersion) {
1090	//check that the current type doesn't extend javax.rmi.CORBA.Stub	1105	//check that the current type doesn't extend javax.rmi.CORBA.Stub
1091	TypeBinding javaxRmiCorbaStub = this.scope.getType(TypeConstants.JAVAX_RMI_CORBA_STUB, 4);	1106	TypeBinding javaxRmiCorbaStub = this.scope.getType(TypeConstants.JAVAX_RMI_CORBA_STUB, 4);
Lines 1172-1177 Link Here
1172	}	1187	}
1173	}	1188	}
1174		1189
		1190	private int findFieldCountFromSuperInterfaces(ReferenceBinding[] superinterfaces) {
		1191	int numOfFields = 0;
		1192	if (superinterfaces == null)
		1193	return numOfFields ;
		1194	for (int i = 0; i < superinterfaces.length; i++) {
		1195	numOfFields += superinterfaces[i].fieldCount();
		1196	numOfFields += findFieldCountFromSuperInterfaces(superinterfaces[i].superInterfaces());
		1197	}
		1198	return numOfFields;
		1199	}
		1200
1175	/**	1201	/**
1176	* Resolve a local type declaration	1202	* Resolve a local type declaration
1177	*/	1203	*/





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) {
			this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL);
			return;
		} 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) {
    		this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL);
    		return;
    	} 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) {
    		this.markNullStatus(local, FlowInfo.POTENTIALLY_NULL);
	    	return;
    	} 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) {

	return source;
}

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$
            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 = 2; j < extraLength; j++) {
					this.extra[j] = new long[length];
				}
			}
			else {
				int oldLength; // might need to grow the arrays
				if (vectorIndex >= (oldLength = this.extra[2].length)) {
					for (int j = 2; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
							(this.extra[j] = new long[vectorIndex + 1]), 0,
							oldLength);
					}
				}
			}
    		mask = 1L << (position % BitCacheSize);
    		this.extra[3][vectorIndex] |= mask;
    		isTrue((this.extra[2][vectorIndex] & 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$
            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 = 2; j < extraLength; j++) {
					this.extra[j] = new long[length];
				}
			}
			else {
				int oldLength; // might need to grow the arrays
				if (vectorIndex >= (oldLength = this.extra[2].length)) {
					for (int j = 2; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
							(this.extra[j] = new long[vectorIndex + 1]), 0,
							oldLength);
					}
				}
			}
    		mask = 1L << (position % BitCacheSize);
    		isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$
    		this.extra[4][vectorIndex] |= mask;
    	}
	}
}

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$
            this.nullBit4 |= 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 = 2; j < extraLength; j++) {
					this.extra[j] = new long[length];
				}
			}
			else {
				int oldLength; // might need to grow the arrays
				if (vectorIndex >= (oldLength = this.extra[2].length)) {
					for (int j = 2; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
							(this.extra[j] = new long[vectorIndex + 1]), 0,
							oldLength);
					}
				}
			}
    		mask = 1L << (position % BitCacheSize);
    		isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$
    		this.extra[5][vectorIndex] |= mask;
    	}
	}
}

public String toString(){
	if (this.extra == null) {
		return "NullInfoRegistry<" + this.nullBit1 //$NON-NLS-1$




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

		// arrays which have the same size

	public int maxFieldCount; // limit between fields and locals

	// Constants
	public static final int BitCacheSize = 64; // 64 bits in a long.
	public int[] nullStatusChangedInAssert; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=303448

	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
		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;
	}

		    & (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)

 * @return <code>true</code> if the check passes (does not return
 *    if the check fails)
 */
protected static boolean isTrue(boolean expression, String message) {
	if (!expression)
		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;

            this.nullBit4 &= mask;
        } else {
    		// use extra vector
        	int vectorIndex = (position / BitCacheSize) - 1;
        	if (this.extra == null || vectorIndex >= this.extra[2].length) {
        		// Some field which hasnt yet been encountered in null analysis is getting its null info reset
        		return;
        	}
    		this.extra[2][vectorIndex]
    		    &= (mask = ~(1L << (position % BitCacheSize)));
    		this.extra[3][vectorIndex] &= mask;
    		this.extra[4][vectorIndex] &= 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$

			}
        } 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);
					}
				}
			}
    		mask = 1L << (position % BitCacheSize);
    		isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$
    		this.extra[5][vectorIndex] |= mask;

	}
}

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$

			}
        } 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);
					}
				}
			}
    		mask = 1L << (position % BitCacheSize);
    		this.extra[3][vectorIndex] |= mask;
    		isTrue((this.extra[2][vectorIndex] & 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$

			}
        } 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);
					}
				}
			}
    		mask = 1L << (position % BitCacheSize);
    		isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$
    		this.extra[4][vectorIndex] |= mask;

	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;
	}

Lines 1220-1223 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java (+4 lines)
1220	MethodBinding[] unResolvedMethods() { // for the MethodVerifier so it doesn't resolve types	1220	MethodBinding[] unResolvedMethods() { // for the MethodVerifier so it doesn't resolve types
1221	return this.methods;	1221	return this.methods;
1222	}	1222	}
		1223
		1224	public FieldBinding[] unResolvedFields() {
		1225	return this.fields;
		1226	}
1223	}	1227	}




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;
}
}

Lines 1115-1118 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java (+4 lines)
1115	}	1115	}
1116	return Binding.NO_TYPE_VARIABLES;	1116	return Binding.NO_TYPE_VARIABLES;
1117	}	1117	}
		1118
		1119	public FieldBinding[] unResolvedFields() {
		1120	return this.fields;
		1121	}
1118	}	1122	}

Lines 1376-1379 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java (+4 lines)
1376	MethodBinding[] unResolvedMethods() { // for the MethodVerifier so it doesn't resolve types	1376	MethodBinding[] unResolvedMethods() { // for the MethodVerifier so it doesn't resolve types
1377	return methods();	1377	return methods();
1378	}	1378	}
		1379
		1380	public FieldBinding[] unResolvedFields() {
		1381	return Binding.NO_FIELDS;
		1382	}
1379	}	1383	}




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}





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[] { "testBug247564f" };
//		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 qualified name reference
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 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);
}

// 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 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 359-365 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (-1 / +21 lines)
359	int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;	359	int DuplicateBlankFinalFieldInitialization = FieldRelated + 82;
360	/** @since 3.6 */	360	/** @since 3.6 */
361	int UnresolvedVariable = FieldRelated + 83;	361	int UnresolvedVariable = FieldRelated + 83;
362		362
363	// variable hiding	363	// variable hiding
364	/** @since 3.0 */	364	/** @since 3.0 */
365	int LocalVariableHidingLocalVariable = Internal + 90;	365	int LocalVariableHidingLocalVariable = Internal + 90;
Lines 1245-1250 Link Here
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 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 (-9 / +160 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	this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL);
		127	return;
		128	} else {
		129	position = local.id + this.maxFieldCount;
		130	}
124	// position is zero-based	131	// position is zero-based
125	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	132	if (position < BitCacheSize) { // use bits
126	// set protected non null	133	// set protected non null
127	this.nullBit1 \|= (1L << position);	134	this.nullBit1 \|= (1L << position);
128	if (COVERAGE_TEST_FLAG) {	135	if (COVERAGE_TEST_FLAG) {
Lines 161-173 Link Here
161	}	168	}
162	}	169	}
163		170
164	public void markAsDefinitelyNonNull(LocalVariableBinding local) {	171	public void markAsDefinitelyNonNull(VariableBinding local) {
165	// protected from non-object locals in calling methods	172	// protected from non-object locals in calling methods
166	if (this != DEAD_END) {	173	if (this != DEAD_END) {
167	this.tagBits \|= NULL_FLAG_MASK;	174	this.tagBits \|= NULL_FLAG_MASK;
168	int position;	175	int position;
169	// position is zero-based	176	// position is zero-based
170	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	177	if (local instanceof FieldBinding) {
		178	this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL);
		179	return;
		180	} else {
		181	position = local.id + this.maxFieldCount;
		182	}
		183	if (position < BitCacheSize) { // use bits
171	// set assigned non null	184	// set assigned non null
172	this.nullBit3 \|= (1L << position);	185	this.nullBit3 \|= (1L << position);
173	if (COVERAGE_TEST_FLAG) {	186	if (COVERAGE_TEST_FLAG) {
Lines 207-219 Link Here
207	}	220	}
208	// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either	221	// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either
209	// PREMATURE project protected non null onto something else	222	// PREMATURE project protected non null onto something else
210	public void markAsDefinitelyNull(LocalVariableBinding local) {	223	public void markAsDefinitelyNull(VariableBinding local) {
211	// protected from non-object locals in calling methods	224	// protected from non-object locals in calling methods
212	if (this != DEAD_END) {	225	if (this != DEAD_END) {
213	this.tagBits \|= NULL_FLAG_MASK;	226	this.tagBits \|= NULL_FLAG_MASK;
214	int position;	227	int position;
		228	if (local instanceof FieldBinding) {
		229	this.markNullStatus(local, FlowInfo.POTENTIALLY_NULL);
		230	return;
		231	} else {
		232	position = local.id + this.maxFieldCount;
		233	}
215	// position is zero-based	234	// position is zero-based
216	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	235	if (position < BitCacheSize) { // use bits
217	// set assigned null	236	// set assigned null
218	this.nullBit2 \|= (1L << position);	237	this.nullBit2 \|= (1L << position);
219	if (COVERAGE_TEST_FLAG) {	238	if (COVERAGE_TEST_FLAG) {
Lines 252-264 Link Here
252	}	271	}
253	}	272	}
254		273
255	public void markAsDefinitelyUnknown(LocalVariableBinding local) {	274	public void markAsDefinitelyUnknown(VariableBinding local) {
256	// protected from non-object locals in calling methods	275	// protected from non-object locals in calling methods
257	if (this != DEAD_END) {	276	if (this != DEAD_END) {
258	this.tagBits \|= NULL_FLAG_MASK;	277	this.tagBits \|= NULL_FLAG_MASK;
259	int position;	278	int position;
		279	if (local instanceof FieldBinding) {
		280	position = local.id;
		281	} else {
		282	position = local.id + this.maxFieldCount;
		283	}
260	// position is zero-based	284	// position is zero-based
261	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	285	if (position < BitCacheSize) { // use bits
262	// set assigned unknown	286	// set assigned unknown
263	this.nullBit4 \|= (1L << position);	287	this.nullBit4 \|= (1L << position);
264	if (COVERAGE_TEST_FLAG) {	288	if (COVERAGE_TEST_FLAG) {
Lines 379-384 Link Here
379	return source;	403	return source;
380	}	404	}
381		405
		406	public void markPotentiallyNullBit(VariableBinding local) {
		407	if (this != DEAD_END) {
		408	this.tagBits \|= NULL_FLAG_MASK;
		409	int position;
		410	long mask;
		411	if (local instanceof FieldBinding) {
		412	position = local.id;
		413	} else {
		414	position = local.id + this.maxFieldCount;
		415	}
		416	if (position < BitCacheSize) {
		417	// use bits
		418	mask = 1L << position;
		419	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$
		420	this.nullBit2 \|= mask;
		421	} else {
		422	// use extra vector
		423	int vectorIndex = (position / BitCacheSize) - 1;
		424	if (this.extra == null) {
		425	int length = vectorIndex + 1;
		426	this.extra = new long[extraLength][];
		427	for (int j = 2; j < extraLength; j++) {
		428	this.extra[j] = new long[length];
		429	}
		430	}
		431	else {
		432	int oldLength; // might need to grow the arrays
		433	if (vectorIndex >= (oldLength = this.extra[2].length)) {
		434	for (int j = 2; j < extraLength; j++) {
		435	System.arraycopy(this.extra[j], 0,
		436	(this.extra[j] = new long[vectorIndex + 1]), 0,
		437	oldLength);
		438	}
		439	}
		440	}
		441	mask = 1L << (position % BitCacheSize);
		442	this.extra[3][vectorIndex] \|= mask;
		443	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$
		444	}
		445	}
		446	}
		447
		448	public void markPotentiallyNonNullBit(VariableBinding local) {
		449	if (this != DEAD_END) {
		450	this.tagBits \|= NULL_FLAG_MASK;
		451	int position;
		452	long mask;
		453	if (local instanceof FieldBinding) {
		454	position = local.id;
		455	} else {
		456	position = local.id + this.maxFieldCount;
		457	}
		458	if (position < BitCacheSize) {
		459	// use bits
		460	mask = 1L << position;
		461	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$
		462	this.nullBit3 \|= mask;
		463	} else {
		464	// use extra vector
		465	int vectorIndex = (position / BitCacheSize) - 1;
		466	if (this.extra == null) {
		467	int length = vectorIndex + 1;
		468	this.extra = new long[extraLength][];
		469	for (int j = 2; j < extraLength; j++) {
470	this.extra[j] = new long[length];
471	}
472	}
473	else {
474	int oldLength; // might need to grow the arrays
475	if (vectorIndex >= (oldLength = this.extra[2].length)) {
476	for (int j = 2; j < extraLength; j++) {
477	System.arraycopy(this.extra[j], 0,
478	(this.extra[j] = new long[vectorIndex + 1]), 0,
479	oldLength);
480	}
481	}
482	}
483	mask = 1L << (position % BitCacheSize);
484	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$
485	this.extra[4][vectorIndex] \|= mask;
486	}
487	}
488	}
489
490	public void markPotentiallyUnknownBit(VariableBinding local) {
491	// protected from non-object locals in calling methods
492	if (this != DEAD_END) {
493	this.tagBits \|= NULL_FLAG_MASK;
494	int position;
495	long mask;
496	if (local instanceof FieldBinding) {
497	position = local.id;
498	} else {
499	position = local.id + this.maxFieldCount;
500	}
501	if (position < BitCacheSize) {
502	// use bits
503	mask = 1L << position;
504	isTrue((this.nullBit1 & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$
505	this.nullBit4 \|= mask;
506	} else {
507	// use extra vector
508	int vectorIndex = (position / BitCacheSize) - 1;
509	if (this.extra == null) {
510	int length = vectorIndex + 1;
511	this.extra = new long[extraLength][];
512	for (int j = 2; j < extraLength; j++) {
513	this.extra[j] = new long[length];
514	}
515	}
516	else {
517	int oldLength; // might need to grow the arrays
518	if (vectorIndex >= (oldLength = this.extra[2].length)) {
519	for (int j = 2; j < extraLength; j++) {
520	System.arraycopy(this.extra[j], 0,
521	(this.extra[j] = new long[vectorIndex + 1]), 0,
522	oldLength);
523	}
524	}
525	}
526	mask = 1L << (position % BitCacheSize);
527	isTrue((this.extra[2][vectorIndex] & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$
528	this.extra[5][vectorIndex] \|= mask;
529	}
530	}
531	}
532
382	public String toString(){	533	public String toString(){
383	if (this.extra == null) {	534	if (this.extra == null) {
384	return "NullInfoRegistry<" + this.nullBit1 //$NON-NLS-1$	535	return "NullInfoRegistry<" + this.nullBit1 //$NON-NLS-1$

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);

Lines 36-42 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/NullReferenceTest.java (-36 / +451 lines)
36	// Only the highest compliance level is run; add the VM argument	36	// Only the highest compliance level is run; add the VM argument
37	// -Dcompliance=1.4 (for example) to lower it if needed	37	// -Dcompliance=1.4 (for example) to lower it if needed
38	static {	38	static {
39	// TESTS_NAMES = new String[] { "testBug325229" };	39	// TESTS_NAMES = new String[] { "testBug247564f" };
40	// TESTS_NUMBERS = new int[] { 561 };	40	// TESTS_NUMBERS = new int[] { 561 };
41	// TESTS_RANGE = new int[] { 1, 2049 };	41	// TESTS_RANGE = new int[] { 1, 2049 };
42	}	42	}
Lines 96-108 Link Here
96	" o.toString();\n" +	96	" o.toString();\n" +
97	" }\n" +	97	" }\n" +
98	"}\n"},	98	"}\n"},
99	""	99	"----------\n" +
100	// "----------\n" +	100	"1. ERROR in X.java (at line 5)\n" +
101	// "1. ERROR in X.java (at line 5)\n" +	101	" o.toString();\n" +
102	// " o.toString();\n" +	102	" ^\n" +
103	// " ^\n" +	103	"Potential null pointer access: The field o may be null at this location\n" +
104	// "The field o is likely null; it was either set to null or checked for null when last used\n" +	104	"----------\n"
105	// "----------\n"
106	);	105	);
107	}	106	}
108		107
Lines 333-345 Link Here
333	" this.o.toString();\n" +	332	" this.o.toString();\n" +
334	" }\n" +	333	" }\n" +
335	"}\n"},	334	"}\n"},
336	""	335	"----------\n" +
337	// "----------\n" +	336	"1. ERROR in X.java (at line 5)\n" +
338	// "1. ERROR in X.java (at line 5)\n" +	337	" this.o.toString();\n" +
339	// " this.o.toString();\n" +	338	" ^\n" +
340	// " ^^^^^^\n" +	339	"Potential null pointer access: The field o may be null at this location\n" +
341	// "The field o is likely null; it was either set to null or checked for null when last used\n" +	340	"----------\n"
342	// "----------\n"
343	);	341	);
344	}	342	}
345		343
Lines 355-367 Link Here
355	" o.toString();\n" +	353	" o.toString();\n" +
356	" }\n" +	354	" }\n" +
357	"}\n"},	355	"}\n"},
358	""	356	"----------\n" +
359	// "----------\n" +	357	"1. ERROR in X.java (at line 5)\n" +
360	// "1. ERROR in X.java (at line 5)\n" +	358	" o.toString();\n" +
361	// " o.toString();\n" +	359	" ^\n" +
362	// " ^\n" +	360	"Potential null pointer access: The field o may be null at this location\n" +
363	// "The field o is likely null; it was either set to null or checked for null when last used\n" +	361	"----------\n"
364	// "----------\n"
365	);	362	);
366	}	363	}
367		364
Lines 411-423 Link Here
411	" }\n" +	408	" }\n" +
412	" }\n" +	409	" }\n" +
413	"}\n"},	410	"}\n"},
414	""	411	"----------\n" +
415	// "----------\n" +	412	"1. ERROR in X.java (at line 6)\n" +
416	// "1. ERROR in X.java (at line 6)\n" +	413	" X.this.o.toString();\n" +
417	// " X.this.o.toString();\n" +	414	" ^\n" +
418	// " ^^^^^^^^\n" +	415	"Potential null pointer access: The field o may be null at this location\n" +
419	// "The field o is likely null; it was either set to null or checked for null when last used\n" +	416	"----------\n"
420	// "----------\n"
421	);	417	);
422	}	418	}
423		419
Lines 436-448 Link Here
436	" }\n" +	432	" }\n" +
437	" void bar() {/* */}\n" +	433	" void bar() {/* */}\n" +
438	"}\n"},	434	"}\n"},
439	""	435	"----------\n" +
440	// "----------\n" +	436	"1. ERROR in X.java (at line 5)\n" +
441	// "1. ERROR in X.java (at line 5)\n" +	437	" o.toString();\n" +
442	// " o.toString();\n" +	438	" ^\n" +
443	// " ^\n" +	439	"Potential null pointer access: The field o may be null at this location\n" +
444	// "The field o is likely null; it was either set to null or checked for null when last used\n" +	440	"----------\n"
445	// "----------\n"
446	);	441	);
447	}	442	}
448		443
Lines 13673-13678 Link Here
13673	"}"},	13668	"}"},
13674	"null220");	13669	"null220");
13675	}	13670	}
		13671
		13672	// null analysis -- simple case for field
		13673	public void testBug247564a() {
		13674	this.runNegativeTest(
		13675	new String[] {
		13676	"X.java",
		13677	"public class X {\n" +
		13678	" Object o;\n" +
		13679	" void foo() {\n" +
		13680	" if (o == null && o.toString() == \"\"){}\n" +
		13681	" else {}\n" +
		13682	" o.toString();\n" + // toString() call above defuses null info, so no warning here
		13683	" }\n" +
		13684	"}\n"},
		13685	"----------\n" +
		13686	"1. ERROR in X.java (at line 4)\n" +
		13687	" if (o == null && o.toString() == \"\"){}\n" +
		13688	" ^\n" +
		13689	"Potential null pointer access: The field o may be null at this location\n" +
		13690	"----------\n"
		13691	);
		13692	}
		13693
		13694	// null analysis -- simple case for field
		13695	// no redundant null check warnings should be obtained since value of field
		13696	// may be changed in another thread.
		13697	public void testBug247564a_1() {
		13698	this.runNegativeTest(
		13699	new String[] {
		13700	"X.java",
		13701	"public class X {\n" +
		13702	" Object o;\n" +
		13703	" void foo() {\n" +
		13704	" o = null;" +
		13705	" if (o == null){}\n" +
		13706	" if (o != null){}\n" +
		13707	" o.toString();\n" + // warn here
		13708	" }\n" +
		13709	"}\n"},
		13710	"----------\n" +
		13711	"1. ERROR in X.java (at line 6)\n" +
		13712	" o.toString();\n" +
		13713	" ^\n" +
		13714	"Potential null pointer access: The field o may be null at this location\n" +
		13715	"----------\n"
		13716	);
		13717	}
		13718
		13719	// null analysis -- simple case for field
		13720	public void testBug247564a_2() {
		13721	this.runNegativeTest(
		13722	new String[] {
		13723	"X.java",
		13724	"public class X {\n" +
		13725	" Object o;\n" +
		13726	" void foo() {\n" +
		13727	" if (o == null){\n" + // o is null inside the if block
		13728	" o.toString();\n" +
		13729	" }\n" +
		13730	" }\n" +
		13731	"}\n"},
		13732	"----------\n" +
		13733	"1. ERROR in X.java (at line 5)\n" +
		13734	" o.toString();\n" +
13735	" ^\n" +
13736	"Potential null pointer access: The field o may be null at this location\n" +
13737	"----------\n"
13738	);
13739	}
13740
13741	// null analysis -- simple case for field
13742	// null info from one method should not be present in the other (for instance fields)
13743	public void testBug247564a_3() {
13744	this.runNegativeTest(
13745	new String[] {
13746	"X.java",
13747	"public class X {\n" +
13748	" Object o;\n" +
13749	" void foo() {\n" +
13750	" }\n" +
13751	" void foo1() {\n" +
13752	" o.toString();\n" +
13753	" }\n" +
13754	"}\n"},
13755	""
13756	);
13757	}
13758
13759	// null analysis -- simple case for static final field
13760	public void testBug247564b() {
13761	this.runNegativeTest(
13762	new String[] {
13763	"X.java",
13764	"public class X {\n" +
13765	" static final Object o = null;\n" +
13766	" static final Object o1 = new Object();\n" +
13767	" void foo() {\n" +
13768	" if (o.toString() == \"\") {}\n" +
13769	" if (o == null) {}\n" +
13770	" if (o != null) {}\n" +
13771	" if (o1 == null) {}\n" +
13772	" if (o1 != null) {}\n" +
13773	" }\n" +
13774	"}\n"},
13775	"----------\n" +
13776	"1. ERROR in X.java (at line 5)\n" +
13777	" if (o.toString() == \"\") {}\n" +
13778	" ^\n" +
13779	"Null pointer access: The field o can only be null at this location\n" +
13780	"----------\n" +
13781	"2. ERROR in X.java (at line 6)\n" +
13782	" if (o == null) {}\n" +
13783	" ^\n" +
13784	"Redundant null check: The field o can only be null at this location\n" +
13785	"----------\n" +
13786	"3. ERROR in X.java (at line 7)\n" +
13787	" if (o != null) {}\n" +
13788	" ^\n" +
13789	"Null comparison always yields false: The field o can only be null at this location\n" +
13790	"----------\n" +
13791	"4. WARNING in X.java (at line 7)\n" +
13792	" if (o != null) {}\n" +
13793	" ^^\n" +
13794	"Dead code\n" +
13795	"----------\n" +
13796	"5. ERROR in X.java (at line 8)\n" +
13797	" if (o1 == null) {}\n" +
13798	" ^^\n" +
13799	"Null comparison always yields false: The field o1 cannot be null at this location\n" +
13800	"----------\n" +
13801	"6. WARNING in X.java (at line 8)\n" +
13802	" if (o1 == null) {}\n" +
13803	" ^^\n" +
13804	"Dead code\n" +
13805	"----------\n" +
13806	"7. ERROR in X.java (at line 9)\n" +
13807	" if (o1 != null) {}\n" +
13808	" ^^\n" +
13809	"Redundant null check: The field o1 cannot be null at this location\n" +
13810	"----------\n"
13811	);
13812	}
13813
13814	// null analysis -- simple case for static final field
13815	public void testBug247564b_1() {
13816	this.runNegativeTest(
13817	new String[] {
13818	"X.java",
13819	"public class X {\n" +
13820	" static final Object o;\n" +
13821	" static final Object o1;\n" +
13822	" static {\n" +
13823	" o = null;\n" +
13824	" o1 = new Object();\n" +
13825	" }\n" +
13826	" void foo() {\n" +
13827	" if (o.toString() == \"\") {}\n" +
13828	" if (o == null) {}\n" +
13829	" if (o != null) {}\n" +
13830	" if (o1 == null) {}\n" +
13831	" if (o1 != null) {}\n" +
13832	" }\n" +
13833	"}\n"},
13834	"----------\n" +
13835	"1. ERROR in X.java (at line 9)\n" +
13836	" if (o.toString() == \"\") {}\n" +
13837	" ^\n" +
13838	"Null pointer access: The field o can only be null at this location\n" +
13839	"----------\n" +
13840	"2. ERROR in X.java (at line 10)\n" +
13841	" if (o == null) {}\n" +
13842	" ^\n" +
13843	"Redundant null check: The field o can only be null at this location\n" +
13844	"----------\n" +
13845	"3. ERROR in X.java (at line 11)\n" +
13846	" if (o != null) {}\n" +
13847	" ^\n" +
13848	"Null comparison always yields false: The field o can only be null at this location\n" +
13849	"----------\n" +
13850	"4. WARNING in X.java (at line 11)\n" +
13851	" if (o != null) {}\n" +
13852	" ^^\n" +
13853	"Dead code\n" +
13854	"----------\n" +
13855	"5. ERROR in X.java (at line 12)\n" +
13856	" if (o1 == null) {}\n" +
13857	" ^^\n" +
13858	"Null comparison always yields false: The field o1 cannot be null at this location\n" +
13859	"----------\n" +
13860	"6. WARNING in X.java (at line 12)\n" +
13861	" if (o1 == null) {}\n" +
13862	" ^^\n" +
13863	"Dead code\n" +
13864	"----------\n" +
13865	"7. ERROR in X.java (at line 13)\n" +
13866	" if (o1 != null) {}\n" +
13867	" ^^\n" +
13868	"Redundant null check: The field o1 cannot be null at this location\n" +
13869	"----------\n"
13870	);
13871	}
13872
13873	// null analysis -- fields in synchronized methods
13874	// check that null analysis for fields in synchronized methods
13875	// behave as it does in ordinary methods.
13876	public void testBug247564c() {
13877	this.runNegativeTest(
13878	new String[] {
13879	"X.java",
13880	"public class X {\n" +
13881	" Object o;\n" +
13882	" Object o1;\n" +
13883	" static final Object o2 = null;\n" +
13884	" static final Object o3 = new Object();\n" +
13885	" synchronized void foo() {\n" +
13886	" o = null;\n" +
13887	" if (o == null) {\n" +
13888	" o.toString();\n" +
13889	" }\n" +
13890	" o1 = new Object();\n" +
13891	" if (o1 == null) {\n" +
13892	" o1.toString();\n" +
13893	" }\n" +
13894	" if (o2 != null) {\n" +
13895	" }\n" +
13896	" else {\n" +
13897	" o2.toString();\n" +
13898	" }\n" +
13899	" if (o3 == null) {\n" +
13900	" }\n" +
13901	" else {\n" +
13902	" o3.toString();\n" +
13903	" }\n" +
13904	" }\n" +
13905	" void foo1() {\n" +
13906	" o.toString();\n" +
13907	" }\n" +
13908	"}\n"},
13909	"----------\n" +
13910	"1. ERROR in X.java (at line 9)\n" +
13911	" o.toString();\n" +
13912	" ^\n" +
13913	"Potential null pointer access: The field o may be null at this location\n" +
13914	"----------\n" +
13915	"2. ERROR in X.java (at line 13)\n" +
13916	" o1.toString();\n" +
13917	" ^^\n" +
13918	"Potential null pointer access: The field o1 may be null at this location\n" +
13919	"----------\n" +
13920	"3. ERROR in X.java (at line 15)\n" +
13921	" if (o2 != null) {\n" +
13922	" ^^\n" +
13923	"Null comparison always yields false: The field o2 can only be null at this location\n" +
13924	"----------\n" +
13925	"4. WARNING in X.java (at line 15)\n" +
13926	" if (o2 != null) {\n" +
13927	" }\n" +
13928	" ^^^^^\n" +
13929	"Dead code\n" +
13930	"----------\n" +
13931	"5. ERROR in X.java (at line 18)\n" +
13932	" o2.toString();\n" +
13933	" ^^\n" +
13934	"Null pointer access: The field o2 can only be null at this location\n" +
13935	"----------\n" +
13936	"6. ERROR in X.java (at line 20)\n" +
13937	" if (o3 == null) {\n" +
13938	" ^^\n" +
13939	"Null comparison always yields false: The field o3 cannot be null at this location\n" +
13940	"----------\n" +
13941	"7. WARNING in X.java (at line 20)\n" +
13942	" if (o3 == null) {\n" +
13943	" }\n" +
13944	" ^^^^^\n" +
13945	"Dead code\n" +
13946	"----------\n"
13947	);
13948	}
13949
13950	// null analysis -- test redundant instanceof warning for static final field
13951	public void testBug247564d() {
13952	this.runNegativeTest(
13953	new String[] {
13954	"X.java",
13955	"public class X {\n" +
13956	" static final Object o = null;\n" +
13957	" static final Object o1 = new Object();\n" +
13958	" void foo() {\n" +
13959	" if (o instanceof String) {}\n" +
13960	" if (o1 instanceof String) {}\n" +
13961	" }\n" +
13962	"}\n"},
13963	"----------\n" +
13964	"1. ERROR in X.java (at line 5)\n" +
13965	" if (o instanceof String) {}\n" +
13966	" ^\n" +
13967	"instanceof always yields false: The field o can only be null at this location\n" +
13968	"----------\n"
13969	);
13970	}
13971
13972	// null analysis -- test redundant instanceof warning for static final fields
13973	public void testBug247564e_1() {
13974	this.runNegativeTest(
13975	new String[] {
13976	"X.java",
13977	"public class X {\n" +
13978	" static final Object o = null;\n" +
13979	" void foo() {\n" +
13980	" if (o instanceof X) return;\n" +
13981	" }\n" +
13982	"}"},
13983	"----------\n" +
13984	"1. ERROR in X.java (at line 4)\n" +
13985	" if (o instanceof X) return;\n" +
13986	" ^\n" +
13987	"instanceof always yields false: The field o can only be null at this location\n" +
13988	"----------\n",
13989	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
13990	}
13991
13992	// null analysis -- test potential null ptr access warning because of static field access through qualified name reference
13993	public void testBug247564f() {
13994	Map compilerOptions = getCompilerOptions();
13995	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
13996	this.runNegativeTest(
13997	false,
13998	new String[] {
13999	"X.java",
14000	"public class X {\n" +
14001	" static Object o;\n" +
14002	" static Object o1;\n" +
14003	" Object o2;\n" +
14004	" X getX() { return new X();\n}\n" +
14005	" void foo() {\n" +
14006	" if (getX().o == null && this.o.hashCode() == 0) return;\n" +
14007	" if (getX().o2 == null && this.o2.hashCode() == 0) return;\n" +
14008	" }\n" +
14009	"}"},
14010	null,
14011	compilerOptions,
14012	"----------\n" +
14013	"1. ERROR in X.java (at line 8)\n" +
14014	" if (getX().o == null && this.o.hashCode() == 0) return;\n" +
14015	" ^\n" +
14016	"Potential null pointer access: The field o may be null at this location\n" +
14017	"----------\n",
14018	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
14019	}
14020
14021	// null analysis -- test field analysis in case of more than 64 fields
14022	public void testBug247564g() {
14023	Map compilerOptions = getCompilerOptions();
14024	compilerOptions.put(CompilerOptions.OPTION_ReportNonStaticAccessToStatic, CompilerOptions.IGNORE);
14025	this.runNegativeTest(
14026	false,
14027	new String[] {
14028	"X.java",
14029	"public class X {\n" +
14030	"Object field0, \n" +
14031	"field1, field2, field3, field4, \n" +
14032	"field5, field6, field7, field8, \n" +
14033	"field9, field10, field11, field12, \n" +
14034	"field13, field14, field15, field16, \n" +
14035	"field17, field18, field19, field20, \n" +
14036	"field21, field22, field23, field24, \n" +
14037	"field25, field26, field27, field28, \n" +
14038	"field29, field30, field31, field32, \n" +
14039	"field33, field34, field35, field36, \n" +
14040	"field37, field38, field39, field40, \n" +
14041	"field41, field42, field43, field44, \n" +
14042	"field45, field46, field47, field48, \n" +
14043	"field49, field50, field51, field52, \n" +
14044	"field53, field54, field55, field56, \n" +
14045	"field57, field58, field59, field60, \n" +
14046	"field61, field62, field63, field64, \n" +
14047	"field65, field66, field67, field68, \n" +
14048	"field69, field70, field71, field72, \n" +
14049	"field73, field74, field75, field76, \n" +
14050	"field77, field78, field79, field80, \n" +
14051	"field81, field82, field83, field84, \n" +
14052	"field85, field86, field87, field88, \n" +
14053	"field89, field90, field91, field92, \n" +
14054	"field93, field94, field95, field96, \n" +
14055	"field97, field98, field99;\n" +
14056	"static final Object field100 = null;\n" +
14057	" void foo() {\n" +
14058	" int i = 0;" +
14059	" while (i<10){\n" +
14060	" i++;\n" +
14061	" if (this.field99 == null && this.field99.hashCode() == 0){}\n" +
14062	" this.field98 = null;\n" +
14063	" }\n" +
14064	" if (this.field98.hashCode() == 0) {}\n" + // should not complain
14065	" this.field97 = null;\n" +
14066	" if (this.field97.hashCode() == 0) {}\n" +
14067	" if (this.field100.hashCode() == 0) {}\n" +
14068	" }\n" +
14069	"}"},
14070	null,
14071	compilerOptions,
14072	"----------\n" +
14073	"1. ERROR in X.java (at line 32)\n" +
14074	" if (this.field99 == null && this.field99.hashCode() == 0){}\n" +
14075	" ^^^^^^^\n" +
14076	"Potential null pointer access: The field field99 may be null at this location\n" +
14077	"----------\n" +
14078	"2. ERROR in X.java (at line 37)\n" +
14079	" if (this.field97.hashCode() == 0) {}\n" +
14080	" ^^^^^^^\n" +
14081	"Potential null pointer access: The field field97 may be null at this location\n" +
14082	"----------\n" +
14083	"3. ERROR in X.java (at line 38)\n" +
14084	" if (this.field100.hashCode() == 0) {}\n" +
14085	" ^^^^^^^^\n" +
14086	"Null pointer access: The field field100 can only be null at this location\n" +
14087	"----------\n",
14088	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
14089	}
14090
13676	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=332637	14091	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=332637
13677	// Dead Code detection removing code that isn't dead	14092	// Dead Code detection removing code that isn't dead
13678	public void testBug332637() {	14093	public void testBug332637() {