Attachment #185536 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 (-3 / +13 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 53-61 Link Here
53	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)	53	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
54	.unconditionalInits();	54	.unconditionalInits();
55	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	55	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
56	flowInfo.markNullStatus(local, nullStatus);	56	boolean isSynchronised = currentScope.isOuterMostMethodSynchronised();
		57	flowInfo.markNullStatus(local, nullStatus, isSynchronised);
57	if (flowContext.initsOnFinally != null)	58	if (flowContext.initsOnFinally != null)
58	flowContext.initsOnFinally.markNullStatus(local, nullStatus);	59	flowContext.initsOnFinally.markNullStatus(local, nullStatus, isSynchronised);
		60	if (local instanceof FieldBinding && local.isFinal() && ((FieldBinding) local).isStatic()) {
		61	// static final field being assigned. Record its null status for future reference
		62	// since the flowInfo from a constructor or static block wont be available in a method
		63	FieldBinding fieldBinding = (FieldBinding) local;
		64	fieldBinding.setNullStatusForStaticFinalField(nullStatus);
		65	}
59	}	66	}
60	return flowInfo;	67	return flowInfo;
61	}	68	}
Lines 205-208 Link Here
205	public LocalVariableBinding localVariableBinding() {	212	public LocalVariableBinding localVariableBinding() {
206	return this.lhs.localVariableBinding();	213	return this.lhs.localVariableBinding();
207	}	214	}
		215	public VariableBinding variableBinding() {
		216	return this.lhs.variableBinding();
		217	}
208	}	218	}

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) {
		boolean isSynchronised = scope.isOuterMostMethodSynchronised();
		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, isSynchronised); // from thereon it is set
					initsWhenFalse.markAsComparedEqualToNonNull(local, isSynchronised ); // from thereon it is set
				} else {
					flowContext.recordUsingNullReference(scope, local, reference,
							FlowContext.CAN_ONLY_NULL_NON_NULL | FlowContext.IN_COMPARISON_NON_NULL, flowInfo);
					initsWhenTrue.markAsComparedEqualToNonNull(local, isSynchronised); // from thereon it is set
					initsWhenFalse.markAsComparedEqualToNull(local, isSynchronised); // from thereon it is set
				}
				if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
					flowInfo.markedAsNullOrNonNullInAssertExpression(local);

				if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
					flowContext.recordUsingNullReference(scope, local, reference,
							FlowContext.CAN_ONLY_NULL | FlowContext.IN_COMPARISON_NON_NULL, flowInfo);
					initsWhenTrue.markAsComparedEqualToNonNull(local, isSynchronised); // from thereon it is set
					if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
						initsWhenTrue.markedAsNullOrNonNullInAssertExpression(local);
					}




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);
		}
		boolean isSynchronised = scope.isOuterMostMethodSynchronised();
		flowInfo.markAsComparedEqualToNonNull(local, isSynchronised );
			// from thereon it is set
		if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
			flowInfo.markedAsNullOrNonNullInAssertExpression(local);
		}
		if (flowContext.initsOnFinally != null) {
			flowContext.initsOnFinally.markAsComparedEqualToNonNull(local, isSynchronised);
			if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
				flowContext.initsOnFinally.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 (+6 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	return this.binding;
		675	}
		676
671	}	677	}




}

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();
		boolean isSynchronised = currentScope.isOuterMostMethodSynchronised();
		initsWhenTrue.markAsComparedEqualToNonNull(variable, isSynchronised );
		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 / +2 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	boolean isSynchronised = currentScope.isOuterMostMethodSynchronised();
		85	flowInfo.markNullStatus(this.binding, nullStatus, isSynchronised );
85	// no need to inform enclosing try block since its locals won't get	86	// no need to inform enclosing try block since its locals won't get
86	// known by the finally block	87	// known by the finally block
87	}	88	}

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

Lines 134-139 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java (+2 lines)
134	}	134	}
135		135
136	}	136	}
		137	// don't let the flow info collected for fields from this method persist.
		138	flowInfo.resetNullInfoForFields();
137	} catch (AbortMethod e) {	139	} catch (AbortMethod e) {
138	this.ignoreFurtherInvestigation = true;	140	this.ignoreFurtherInvestigation = true;
139	}	141	}




				flowContext.recordUsingNullReference(scope, local, this,
					FlowContext.MAY_NULL, flowInfo);
			}
			boolean isSynchronised = scope.isOuterMostMethodSynchronised();
			flowInfo.markAsComparedEqualToNonNull(local, isSynchronised );
			// from thereon it is set
			if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
				flowInfo.markedAsNullOrNonNullInAssertExpression(local);
			}
			if (flowContext.initsOnFinally != null) {
				flowContext.initsOnFinally.markAsComparedEqualToNonNull(local, isSynchronised);
				if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
					flowContext.initsOnFinally.markedAsNullOrNonNullInAssertExpression(local);
				}




	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
}




	if (this.returnAddressVariable != null) { // TODO (philippe) if subroutine is escaping, unused
		this.returnAddressVariable.useFlag = LocalVariableBinding.USED;
	}
	boolean isSynchronised = currentScope.isOuterMostMethodSynchronised();
	if (this.subRoutineStartLabel == null) {
		// no finally block -- this is a simplified copy of the else part
		// process the try block in a context handling the local exceptions.

				// catch var is always set
				LocalVariableBinding catchArg = this.catchArguments[i].binding;
				catchInfo.markAsDefinitelyAssigned(catchArg);
				catchInfo.markAsDefinitelyNonNull(catchArg, isSynchronised);
				/*
				"If we are about to consider an unchecked exception handler, potential inits may have occured inside
				the try block that need to be detected , e.g.

				// catch var is always set
				LocalVariableBinding catchArg = this.catchArguments[i].binding;
				catchInfo.markAsDefinitelyAssigned(catchArg);
				catchInfo.markAsDefinitelyNonNull(catchArg, isSynchronised);
				/*
				"If we are about to consider an unchecked exception handler, potential inits may have occured inside
				the try block that need to be detected , e.g.

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, boolean isSynchronised) {
	this.initsWhenTrue.markAsComparedEqualToNonNull(local, isSynchronised);
	this.initsWhenFalse.markAsComparedEqualToNonNull(local, isSynchronised);
}

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

public void markAsDefinitelyAssigned(FieldBinding field) {

	this.initsWhenFalse.markAsDefinitelyAssigned(local);
}

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

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

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().reportRedundantCheckOnNonNullProblem(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().reportNonNullComparedToNullProblem(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().reportNullReferenceProblem(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().reportRedundantCheckOnNullProblem(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().reportNullReferenceProblem(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().reportNullComparedToNonNullProblem(local, expression);
								}
								continue;
							case FlowContext.IN_ASSIGNMENT:
								scope.problemReporter().reportRedundantNullAssignmentProblem(local, expression);
								continue;
							case FlowContext.IN_INSTANCEOF:
								scope.problemReporter().reportNullInstanceofProblem(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().reportPotentialNullReferenceProblem(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().reportPotentialNullReferenceProblem(local, expression);
									continue;
								}
								break;

					break;
				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						scope.problemReporter().reportNullReferenceProblem(local, expression);
						continue;
					}
					if (flowInfo.isPotentiallyNull(local)) {
						scope.problemReporter().reportPotentialNullReferenceProblem(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().reportRedundantCheckOnNonNullProblem(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().reportNonNullComparedToNullProblem(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().reportNullReferenceProblem(local, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().reportRedundantCheckOnNullProblem(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().reportNullReferenceProblem(local, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().reportNullComparedToNonNullProblem(local, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
										flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
									}
									return;
								case FlowContext.IN_ASSIGNMENT:
									scope.problemReporter().reportRedundantNullAssignmentProblem(local, reference);
									return;
								case FlowContext.IN_INSTANCEOF:
									scope.problemReporter().reportNullInstanceofProblem(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().reportPotentialNullReferenceProblem(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().reportPotentialNullReferenceProblem(local, reference);
										return;
									}
									break;

							return;
						}
						if (flowInfo.canOnlyBeNull(local)) {
							scope.problemReporter().reportNullReferenceProblem(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().reportRedundantCheckOnNonNullProblem(local, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
									flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
								}
							} else {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().reportNonNullComparedToNullProblem(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().reportNullReferenceProblem(local, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().reportRedundantCheckOnNullProblem(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().reportNullReferenceProblem(local, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().reportNullComparedToNonNullProblem(local, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
										flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
									}
									return;
								case FlowContext.IN_ASSIGNMENT:
									scope.problemReporter().reportRedundantNullAssignmentProblem(local, reference);
									return;
								case FlowContext.IN_INSTANCEOF:
									scope.problemReporter().reportNullInstanceofProblem(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().reportPotentialNullReferenceProblem(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().reportPotentialNullReferenceProblem(local, reference);
										return;
									}
									break;

						break;
					case MAY_NULL :
						if (flowInfo.isDefinitelyNull(local)) {
							scope.problemReporter().reportNullReferenceProblem(local, reference);
							return;
						}
						if (flowInfo.isPotentiallyNull(local)) {
							scope.problemReporter().reportPotentialNullReferenceProblem(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().reportRedundantCheckOnNonNullProblem(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().reportNonNullComparedToNullProblem(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().reportNullReferenceProblem(local, reference);
							return;
						}
						if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
							scope.problemReporter().reportRedundantCheckOnNullProblem(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().reportNullReferenceProblem(local, reference);
							return;
						}
						if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
							scope.problemReporter().reportNullComparedToNonNullProblem(local, reference);
						}
						if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
							flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
						}
						return;
					case FlowContext.IN_ASSIGNMENT:
						scope.problemReporter().reportRedundantNullAssignmentProblem(local, reference);
						return;
					case FlowContext.IN_INSTANCEOF:
						scope.problemReporter().reportNullInstanceofProblem(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().reportPotentialNullReferenceProblem(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().reportPotentialNullReferenceProblem(local, reference);
							return;
						}
						break;

			break;
		case MAY_NULL :
			if (flowInfo.isDefinitelyNull(local)) {
				scope.problemReporter().reportNullReferenceProblem(local, reference);
				return;
			}
			if (flowInfo.isPotentiallyNull(local)) {
				scope.problemReporter().reportPotentialNullReferenceProblem(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
 * @param isSynchronised whether the enclosing method is synchronized (needed for analysis of fields)
 */
abstract public void markAsComparedEqualToNonNull(VariableBinding binding, boolean isSynchronised);

/**
 * Record that a field or local variable got checked to be null.
 * @param binding the checked field or local variable
 * @param isSynchronised whether the enclosing method is synchronized (needed for analysis of fields)
 */
abstract public void markAsComparedEqualToNull(VariableBinding binding, boolean isSynchronised);

	/**
	 * 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, boolean isSynchronised);

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

	/**
	 * 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, boolean isSynchronised) {
	switch(nullStatus) {
		// definite status?
		case FlowInfo.UNKNOWN :
			markAsDefinitelyUnknown(binding);
			break;
		case FlowInfo.NULL :
			markAsDefinitelyNull(binding, isSynchronised);
			break;
		case FlowInfo.NON_NULL :
			markAsDefinitelyNonNull(binding, isSynchronised);
			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().reportRedundantCheckOnNonNullProblem(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().reportNonNullComparedToNullProblem(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().reportRedundantCheckOnNonNullProblem(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().reportNonNullComparedToNullProblem(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().reportRedundantCheckOnNullProblem(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().reportNullComparedToNonNullProblem(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().reportNullReferenceProblem(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().reportRedundantCheckOnNullProblem(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().reportNullReferenceProblem(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().reportNullComparedToNonNullProblem(local, expression);
								}
								continue;
							case FlowContext.IN_ASSIGNMENT:
								scope.problemReporter().reportRedundantNullAssignmentProblem(local, expression);
								continue;
							case FlowContext.IN_INSTANCEOF:
								scope.problemReporter().reportNullInstanceofProblem(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().reportPotentialNullReferenceProblem(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().reportPotentialNullReferenceProblem(local, expression);
									continue;
								}
								break;

				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().reportNullReferenceProblem(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().reportRedundantCheckOnNonNullProblem(local, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().reportNonNullComparedToNullProblem(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().reportNullReferenceProblem(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().reportRedundantCheckOnNullProblem(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().reportNullReferenceProblem(local, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().reportNullComparedToNonNullProblem(local, expression);
								}
								continue;
							case FlowContext.IN_ASSIGNMENT:
								if (local instanceof LocalVariableBinding) {
									scope.problemReporter().localVariableRedundantNullAssignment((LocalVariableBinding) local, expression);
								}
								continue;
							case FlowContext.IN_INSTANCEOF:
								if (local instanceof LocalVariableBinding) {
									scope.problemReporter().localVariableNullInstanceof((LocalVariableBinding) 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().reportPotentialNullReferenceProblem(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().reportPotentialNullReferenceProblem(local, expression);
									continue;
								}
								break;

				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().reportNullReferenceProblem(local, expression);
						continue;
					}
					if (flowInfo.isPotentiallyNull(local)) {
						this.nullReferences[i] = null;
						scope.problemReporter().reportPotentialNullReferenceProblem(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().reportRedundantCheckOnNonNullProblem(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().reportNonNullComparedToNullProblem(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().reportRedundantCheckOnNullProblem(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().reportNullComparedToNonNullProblem(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
				boolean isSynchronised = scope.isOuterMostMethodSynchronised();
				flowInfo.markAsDefinitelyNonNull(local, isSynchronised );
				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().reportNullReferenceProblem(local, reference);
							return;
						}
						if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
							scope.problemReporter().reportRedundantCheckOnNullProblem(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().reportNullReferenceProblem(local, reference);
							return;
						}
						if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
							scope.problemReporter().reportNullComparedToNonNullProblem(local, reference);
						}
						if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
							flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
						}
						return;
					case FlowContext.IN_ASSIGNMENT:
						scope.problemReporter().reportRedundantNullAssignmentProblem(local, reference);
						return;
					case FlowContext.IN_INSTANCEOF:
						scope.problemReporter().reportNullInstanceofProblem(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().reportPotentialNullReferenceProblem(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().reportPotentialNullReferenceProblem(local, reference);
							return;
						}
						break;

				return;
			}
			if (flowInfo.isDefinitelyNull(local)) {
				scope.problemReporter().reportNullReferenceProblem(local, reference);
				return;
			}
			if (flowInfo.isPotentiallyNull(local)) {
				scope.problemReporter().reportPotentialNullReferenceProblem(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

		}
		if (upstream.extra != null) {
			this.extra = new long[extraLength][];
			int length = upstream.extra[0].length;
			for (int i = 0; i < extraLength; i++) {
				this.extra[i] = new long[length];
			}
			for (int i = 0; i < length; i++) {

	if (other.extra != null) {
		if (this.extra == null) {
			this.extra = new long[extraLength][];
			for (int i = 0, length = other.extra[0].length; i < extraLength; i++) {
				System.arraycopy(other.extra[i], 0,
					(this.extra[i] = new long[length]), 0, length);
			}
		} else {
			int length = this.extra[0].length, otherLength = other.extra[0].length;
			if (otherLength > length) {
				for (int i = 0; i < extraLength; i++) {
					System.arraycopy(this.extra[i], 0,
						(this.extra[i] = new long[otherLength]), 0, length);
					System.arraycopy(other.extra[i], length,

			} else if (otherLength < length) {
				length = otherLength;
			}
			for (int i = 0; i < extraLength; i++) {
				for (int j = 0; j < length; j++) {
					this.extra[i][j] |= other.extra[i][j];
				}

	return this;
}

public void markAsComparedEqualToNonNull(VariableBinding local, boolean isSynchronised) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	int position;
    	if (local instanceof FieldBinding) {
			if (isSynchronised) {
    			position = local.id;
    		} else {
				this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL, isSynchronised);
				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) {

			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[2].length)) {
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
							(this.extra[j] = new long[vectorIndex + 1]), 0,
							oldLength);

	}
}

public void markAsDefinitelyNonNull(VariableBinding local, boolean isSynchronised) {
	// 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) {
    		if (isSynchronised) {
    			position = local.id;
    		} else {
    			this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL, isSynchronised);
    			return;
    		}
    	} else {
    		position = local.id + this.maxFieldCount;
    	}
    	if (position < BitCacheSize) { // use bits
    		// set assigned non null
    		this.nullBit3 |= (1L << position);
    		if (COVERAGE_TEST_FLAG) {

			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[2].length)) {
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
							(this.extra[j] = new long[vectorIndex + 1]), 0,
							oldLength);

}
// 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, boolean isSynchronised) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	int position;
    	if (local instanceof FieldBinding) {
    		if (isSynchronised) {
    			position = local.id;
    		} else {
	    		this.markNullStatus(local, FlowInfo.POTENTIALLY_NULL, isSynchronised);
	    		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) {

			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[2].length)) {
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
							(this.extra[j] = new long[vectorIndex + 1]), 0,
							oldLength);

	}
}

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

			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[2].length)) {
					for (int j = 0; j < extraLength; j++) {
						System.arraycopy(this.extra[j], 0,
							(this.extra[j] = new long[vectorIndex + 1]), 0,
							oldLength);




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)

		throw new AssertionFailedException("assertion failed: " + message); //$NON-NLS-1$
	return expression;
}
public void markAsComparedEqualToNonNull(VariableBinding local, boolean isSynchronised) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		int position;
		if (local instanceof FieldBinding) {
			if (isSynchronised) {
    			position = local.id;
    		} else {
				this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL, isSynchronised);
				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, boolean isSynchronised) {
	// 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) {
			if (isSynchronised) {
    			position = local.id;
    		} else {
				this.markNullStatus(local, FlowInfo.POTENTIALLY_NULL, isSynchronised);
				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, boolean isSynchronised) {
	// 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) {
    		if (isSynchronised) {
    			position = local.id;
    		} else {
    			this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL, isSynchronised);
    			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, boolean isSynchronised) {
	// 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) {
    		if (isSynchronised) {
    			position = local.id;
    		} else {
	    		this.markNullStatus(local, FlowInfo.POTENTIALLY_NULL, isSynchronised);
	    		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) {
				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;

	}
}

public void resetNullInfoForFields() {
	if (this != DEAD_END) {
		for (int position = 0; position < this.maxFieldCount; position++) {
			long mask;
	        if (position < BitCacheSize) {
	            // use bits
	            this.nullBit1 &= (mask = ~(1L << position));
	            this.nullBit2 &= mask;
	            this.nullBit3 &= mask;
	            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 = 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;
	    		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) {

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




		} while (scope != null);
		return lastMethodScope; // may answer null if no method around
	}
	
	public boolean isOuterMostMethodSynchronised() {
		MethodScope outerMostMethodScope = this.outerMostMethodScope();
		boolean isSynchronised = false;
		if(outerMostMethodScope != null) {
			AbstractMethodDeclaration referenceMethod = outerMostMethodScope.referenceMethod();
			if(referenceMethod != null && referenceMethod.binding != null) {
				isSynchronised = referenceMethod.binding.isSynchronized();
			}
		}
		return isSynchronised;
	}

	public int parameterCompatibilityLevel(MethodBinding method, TypeBinding[] arguments) {
		TypeBinding[] parameters = method.parameters;




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 reportNonNullComparedToNullProblem(VariableBinding variable, ASTNode location) {
	if (variable instanceof FieldBinding) {
		this.fieldNonNullComparedToNull((FieldBinding)variable, location);
	} else {
		this.localVariableNonNullComparedToNull((LocalVariableBinding)variable, location);
	}
}

public void localVariableNonNullComparedToNull(LocalVariableBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.NonNullLocalVariableComparisonYieldsFalse);
	if (severity == ProblemSeverities.Ignore) return;

		nodeSourceEnd(local, location));
}

public void fieldNonNullComparedToNull(FieldBinding field, ASTNode location) {
	int severity = computeSeverity(IProblem.NonNullFieldComparisonYieldsFalse);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(field.name)  };
	this.handle(
		IProblem.NonNullFieldComparisonYieldsFalse,
		arguments,
		arguments,
		severity,
		nodeSourceStart(field, location),
		nodeSourceEnd(field, location));
}

public void reportNullComparedToNonNullProblem(VariableBinding variable, ASTNode location) {
	if (variable instanceof FieldBinding) {
		//if (variable.isFinal() && ((FieldBinding)variable).isStatic())
			this.fieldNullComparedToNonNull((FieldBinding)variable, location);
	} else {
		this.localVariableNullComparedToNonNull((LocalVariableBinding)variable, location);
	}
}

public void localVariableNullComparedToNonNull(LocalVariableBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.NullLocalVariableComparisonYieldsFalse);
	if (severity == ProblemSeverities.Ignore) return;

		nodeSourceEnd(local, location));
}

public void fieldNullComparedToNonNull(FieldBinding field, ASTNode location) {
	int severity = computeSeverity(IProblem.NullFieldComparisonYieldsFalse);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(field.name)  };
	this.handle(
		IProblem.NullFieldComparisonYieldsFalse,
		arguments,
		arguments,
		severity,
		nodeSourceStart(field, location),
		nodeSourceEnd(field, location));
}

public void reportNullInstanceofProblem(VariableBinding variable, ASTNode location) {
	if (variable instanceof FieldBinding) {
		this.fieldNullInstanceof((FieldBinding) variable, location);
	} else {
		this.localVariableNullInstanceof((LocalVariableBinding) variable, location);
	}
}

public void localVariableNullInstanceof(LocalVariableBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.NullLocalVariableInstanceofYieldsFalse);
	if (severity == ProblemSeverities.Ignore) return;

		nodeSourceEnd(local, location));
}

public void fieldNullInstanceof(FieldBinding field, ASTNode location) {
	int severity = computeSeverity(IProblem.NullFieldInstanceofYieldsFalse);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(field.name)  };
	this.handle(
		IProblem.NullFieldInstanceofYieldsFalse,
		arguments,
		arguments,
		severity,
		nodeSourceStart(field, location),
		nodeSourceEnd(field, location));
}

public void reportNullReferenceProblem(VariableBinding variable, ASTNode location) {
	if (variable instanceof FieldBinding) {
		this.fieldNullReference((FieldBinding) variable, location);
	} else {
		this.localVariableNullReference((LocalVariableBinding) variable, location);
	}
}

public void localVariableNullReference(LocalVariableBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.NullLocalVariableReference);
	if (severity == ProblemSeverities.Ignore) return;

		nodeSourceEnd(local, location));
}

public void fieldNullReference(FieldBinding field, ASTNode location) {
	int severity = computeSeverity(IProblem.NullFieldReference);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(field.name)  };
	this.handle(
		IProblem.NullFieldReference,
		arguments,
		arguments,
		severity,
		nodeSourceStart(field, location),
		nodeSourceEnd(field, location));
}

public void reportPotentialNullReferenceProblem(VariableBinding variable, ASTNode location) {
	if (variable instanceof FieldBinding) {
		this.fieldPotentialNullReference((FieldBinding) variable, location);
	} else {
		this.localVariablePotentialNullReference((LocalVariableBinding) variable, location);
	}
}

public void localVariablePotentialNullReference(LocalVariableBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.PotentialNullLocalVariableReference);
	if (severity == ProblemSeverities.Ignore) return;

		nodeSourceEnd(local, location));
}

public void fieldPotentialNullReference(FieldBinding field, ASTNode location) {
	int severity = computeSeverity(IProblem.PotentialNullFieldReference);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(field.name)};
	this.handle(
		IProblem.PotentialNullFieldReference,
		arguments,
		arguments,
		severity,
		nodeSourceStart(field, location),
		nodeSourceEnd(field, location));
}

public void reportRedundantCheckOnNonNullProblem(VariableBinding variable, ASTNode location) {
	if (variable instanceof FieldBinding) {
		this.fieldRedundantCheckOnNonNull((FieldBinding) variable, location);
	} else {
		this.localVariableRedundantCheckOnNonNull((LocalVariableBinding) variable, location);
	}
}

public void localVariableRedundantCheckOnNonNull(LocalVariableBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.RedundantNullCheckOnNonNullLocalVariable);
	if (severity == ProblemSeverities.Ignore) return;

		nodeSourceEnd(local, location));
}

public void fieldRedundantCheckOnNonNull(FieldBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.RedundantNullCheckOnNonNullField);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(local.name)  };
	this.handle(
		IProblem.RedundantNullCheckOnNonNullField,
		arguments,
		arguments,
		severity,
		nodeSourceStart(local, location),
		nodeSourceEnd(local, location));
}

public void reportRedundantCheckOnNullProblem (VariableBinding variable, ASTNode location) {
	if (variable instanceof FieldBinding) {
		this.fieldRedundantCheckOnNull((FieldBinding)variable, location);
	} else {
		this.localVariableRedundantCheckOnNull((LocalVariableBinding)variable, location);
	}
}

public void localVariableRedundantCheckOnNull(LocalVariableBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.RedundantNullCheckOnNullLocalVariable);
	if (severity == ProblemSeverities.Ignore) return;

		nodeSourceEnd(local, location));
}

public void fieldRedundantCheckOnNull(FieldBinding field, ASTNode location) {
	int severity = computeSeverity(IProblem.RedundantNullCheckOnNullField);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(field.name)  };
	this.handle(
		IProblem.RedundantNullCheckOnNullField,
		arguments,
		arguments,
		severity,
		nodeSourceStart(field, location),
		nodeSourceEnd(field, location));
}

public void reportRedundantNullAssignmentProblem (VariableBinding variable, ASTNode location) {
	if (variable instanceof FieldBinding) {
		this.fieldRedundantNullAssignment((FieldBinding)variable, location);
	} else {
		this.localVariableRedundantNullAssignment((LocalVariableBinding)variable, location);
	}
}

public void localVariableRedundantNullAssignment(LocalVariableBinding local, ASTNode location) {
	int severity = computeSeverity(IProblem.RedundantLocalVariableNullAssignment);
	if (severity == ProblemSeverities.Ignore) return;

		nodeSourceEnd(local, location));
}

public void fieldRedundantNullAssignment(FieldBinding field, ASTNode location) {
	int severity = computeSeverity(IProblem.RedundantFieldNullAssignment);
	if (severity == ProblemSeverities.Ignore) return;
	String[] arguments = new String[] {new String(field.name)  };
	this.handle(
		IProblem.RedundantFieldNullAssignment,
		arguments,
		arguments,
		severity,
		nodeSourceStart(field, location),
		nodeSourceEnd(field, location));
}

public void methodMustOverride(AbstractMethodDeclaration method, long complianceLevel) {
	MethodBinding binding = method.binding;
	this.handle(




### 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

					result2 = (UnconditionalFlowInfoTestHarness) source1.copy();
					if (source2.isDefinitelyNonNull(TestLocalVariableBinding.local0)) {
						if (! source2.isProtectedNonNull(TestLocalVariableBinding.local0)) {
							result1.markAsDefinitelyNonNull(TestLocalVariableBinding.local0, false);
						} else {
							continue;
						}

	return copy;
}

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

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, false);
}

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





				UnconditionalFlowInfo output(UnconditionalFlowInfo input,
						TestLocalVariableBinding local) {
					UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();
					result.markAsComparedEqualToNonNull(local, false);
					return result;
				}
			},

			UnconditionalFlowInfo output(UnconditionalFlowInfo input,
					TestLocalVariableBinding local) {
				UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();
				result.markAsComparedEqualToNull(local, false);
				return result;
			}
		},

			UnconditionalFlowInfo output(UnconditionalFlowInfo input,
					TestLocalVariableBinding local) {
				UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();
				result.markAsDefinitelyNonNull(local, false);
				return result;
			}
		},

			UnconditionalFlowInfo output(UnconditionalFlowInfo input,
					TestLocalVariableBinding local) {
				UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();
				result.markAsDefinitelyNull(local, false);
				return result;
			}
		},




// 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[] { "test0002_simple_field" };
//		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" + 
		"Null pointer access: The field o can only 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 fields that are protected against concurrent access
// behave as locals when no call to further methods can affect them
public void testBug247564c() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  Object o1;\n" +
			"  Object o2;\n" +
			"  Object o3;\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" +
			"		o2 = null;\n" +
			"		if (o2 != null) {\n" +
			"		}\n" +
			"		else {\n" +
			"			o2.toString();\n" +
			"		}\n" +
			"		o3 = new Object();\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 8)\n" + 
		"	if (o == null) {\n" + 
		"	    ^\n" + 
		"Redundant null check: The field o can only be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 9)\n" + 
		"	o.toString();\n" + 
		"	^\n" + 
		"Null pointer access: The field o can only be null at this location\n" + 
		"----------\n" + 
		"3. 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" + 
		"4. WARNING in X.java (at line 12)\n" + 
		"	if (o1 == null) {\n" + 
		"			o1.toString();\n" + 
		"		}\n" + 
		"	                ^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 16)\n" + 
		"	if (o2 != null) {\n" + 
		"	    ^^\n" + 
		"Null comparison always yields false: The field o2 can only be null at this location\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 16)\n" + 
		"	if (o2 != null) {\n" + 
		"		}\n" + 
		"	                ^^^^^\n" + 
		"Dead code\n" + 
		"----------\n" + 
		"7. ERROR in X.java (at line 19)\n" + 
		"	o2.toString();\n" + 
		"	^^\n" + 
		"Null pointer access: The field o2 can only be null at this location\n" + 
		"----------\n" + 
		"8. ERROR in X.java (at line 22)\n" + 
		"	if (o3 == null) {\n" + 
		"	    ^^\n" + 
		"Null comparison always yields false: The field o3 cannot be null at this location\n" + 
		"----------\n" + 
		"9. WARNING in X.java (at line 22)\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 fields in synchronised method
public void testBug247564d_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  Object o1;\n" +
			"  synchronized void foo() {\n" +
			"    if (o == null && o instanceof String) {}\n" +
			"	 o1 = null;\n" +
			"    if (o1 instanceof String) {}\n" +
			"  }\n" +
			"  void foo1() {\n" +
			"    if (o == null && o instanceof String) {}\n" +
			"	 o1 = null;\n" +
			"    if (o1 instanceof String) {}\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	if (o == null && o instanceof String) {}\n" + 
		"	                 ^\n" + 
		"instanceof always yields false: The field o can only be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 7)\n" + 
		"	if (o1 instanceof String) {}\n" + 
		"	    ^^\n" + 
		"instanceof always yields false: The field o1 can only be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- test redundant instanceof warning for fields in synchronised method
public void testBug247564e() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  synchronized void foo() {\n" +
			"    if (o == null) { o = null;}\n" +
			"  }\n" +
			"  void foo1() {\n" +
			"    if (o == null) { o = null;}\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	if (o == null) { o = null;}\n" + 
		"	                 ^\n" + 
		"Redundant assignment: The field o can only be null at this location\n" + 
		"----------\n"
	);
}

// null analysis -- test redundant instanceof warning for fields in synchronised method
public void testBug247564e_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"  Object o;\n" +
			"  synchronized void foo() {\n" +
			"    o = null;" +
			"    do {\n" +
			"      if (o != null) return;\n" +
			"      o = null;\n" +
			"    } while (true);\n" +
			"  }\n" +
			"}"},
		"----------\n" +
		"1. ERROR in X.java (at line 5)\n" + 
		"	if (o != null) return;\n" + 
		"	    ^\n" + 
		"Null comparison always yields false: The field o can only be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	o = null;\n" + 
		"	^\n" + 
		"Redundant assignment: The field o 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 235-247 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-2 / +3 lines)
235	flowContext.recordUsingNullReference(scope, local, this,	235	flowContext.recordUsingNullReference(scope, local, this,
236	FlowContext.MAY_NULL, flowInfo);	236	FlowContext.MAY_NULL, flowInfo);
237	}	237	}
238	flowInfo.markAsComparedEqualToNonNull(local);	238	boolean isSynchronised = scope.isOuterMostMethodSynchronised();
		239	flowInfo.markAsComparedEqualToNonNull(local, isSynchronised );
239	// from thereon it is set	240	// from thereon it is set
240	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	241	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
241	flowInfo.markedAsNullOrNonNullInAssertExpression(local);	242	flowInfo.markedAsNullOrNonNullInAssertExpression(local);
242	}	243	}
243	if (flowContext.initsOnFinally != null) {	244	if (flowContext.initsOnFinally != null) {
244	flowContext.initsOnFinally.markAsComparedEqualToNonNull(local);	245	flowContext.initsOnFinally.markAsComparedEqualToNonNull(local, isSynchronised);
245	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	246	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
246	flowContext.initsOnFinally.markedAsNullOrNonNullInAssertExpression(local);	247	flowContext.initsOnFinally.markedAsNullOrNonNullInAssertExpression(local);
247	}	248	}

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 23-29 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/FlowContext.java (-15 / +14 lines)
23	import org.eclipse.jdt.internal.compiler.codegen.BranchLabel;	23	import org.eclipse.jdt.internal.compiler.codegen.BranchLabel;
24	import org.eclipse.jdt.internal.compiler.lookup.Binding;	24	import org.eclipse.jdt.internal.compiler.lookup.Binding;
25	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;	25	import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
26	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
27	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;	26	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
28	import org.eclipse.jdt.internal.compiler.lookup.Scope;	27	import org.eclipse.jdt.internal.compiler.lookup.Scope;
29	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	28	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
Lines 520-526 Link Here
520	* combined with a context indicator (one of {@link #IN_COMPARISON_NULL},	519	* combined with a context indicator (one of {@link #IN_COMPARISON_NULL},
521	* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})	520	* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})
522	*/	521	*/
523	protected void recordNullReference(LocalVariableBinding local,	522	protected void recordNullReference(VariableBinding local,
524	Expression expression, int status) {	523	Expression expression, int status) {
525	// default implementation: do nothing	524	// default implementation: do nothing
526	}	525	}
Lines 563-569 Link Here
563	* be known at the time of calling this method (they are influenced by	562	* be known at the time of calling this method (they are influenced by
564	* code that follows the current point)	563	* code that follows the current point)
565	*/	564	*/
566	public void recordUsingNullReference(Scope scope, LocalVariableBinding local,	565	public void recordUsingNullReference(Scope scope, VariableBinding local,
567	Expression reference, int checkType, FlowInfo flowInfo) {	566	Expression reference, int checkType, FlowInfo flowInfo) {
568	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 \|\|	567	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 \|\|
569	flowInfo.isDefinitelyUnknown(local)) {	568	flowInfo.isDefinitelyUnknown(local)) {
Lines 575-588 Link Here
575	if (flowInfo.isDefinitelyNonNull(local)) {	574	if (flowInfo.isDefinitelyNonNull(local)) {
576	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {	575	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {
577	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	576	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
578	scope.problemReporter().localVariableRedundantCheckOnNonNull(local, reference);	577	scope.problemReporter().reportRedundantCheckOnNonNullProblem(local, reference);
579	}	578	}
580	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	579	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
581	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);	580	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
582	}	581	}
583	} else {	582	} else {
584	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	583	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
585	scope.problemReporter().localVariableNonNullComparedToNull(local, reference);	584	scope.problemReporter().reportNonNullComparedToNullProblem(local, reference);
586	}	585	}
587	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	586	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
588	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);	587	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
Lines 602-612 Link Here
602	switch(checkType & CONTEXT_MASK) {	601	switch(checkType & CONTEXT_MASK) {
603	case FlowContext.IN_COMPARISON_NULL:	602	case FlowContext.IN_COMPARISON_NULL:
604	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	603	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
605	scope.problemReporter().localVariableNullReference(local, reference);	604	scope.problemReporter().reportNullReferenceProblem(local, reference);
606	return;	605	return;
607	}	606	}
608	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	607	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
609	scope.problemReporter().localVariableRedundantCheckOnNull(local, reference);	608	scope.problemReporter().reportRedundantCheckOnNullProblem(local, reference);
610	}	609	}
611	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	610	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
612	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);	611	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE);
Lines 614-647 Link Here
614	return;	613	return;
615	case FlowContext.IN_COMPARISON_NON_NULL:	614	case FlowContext.IN_COMPARISON_NON_NULL:
616	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	615	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
617	scope.problemReporter().localVariableNullReference(local, reference);	616	scope.problemReporter().reportNullReferenceProblem(local, reference);
618	return;	617	return;
619	}	618	}
620	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	619	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
621	scope.problemReporter().localVariableNullComparedToNonNull(local, reference);	620	scope.problemReporter().reportNullComparedToNonNullProblem(local, reference);
622	}	621	}
623	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	622	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
624	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);	623	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE);
625	}	624	}
626	return;	625	return;
627	case FlowContext.IN_ASSIGNMENT:	626	case FlowContext.IN_ASSIGNMENT:
628	scope.problemReporter().localVariableRedundantNullAssignment(local, reference);	627	scope.problemReporter().reportRedundantNullAssignmentProblem(local, reference);
629	return;	628	return;
630	case FlowContext.IN_INSTANCEOF:	629	case FlowContext.IN_INSTANCEOF:
631	scope.problemReporter().localVariableNullInstanceof(local, reference);	630	scope.problemReporter().reportNullInstanceofProblem(local, reference);
632	return;	631	return;
633	}	632	}
634	} else if (flowInfo.isPotentiallyNull(local)) {	633	} else if (flowInfo.isPotentiallyNull(local)) {
635	switch(checkType & CONTEXT_MASK) {	634	switch(checkType & CONTEXT_MASK) {
636	case FlowContext.IN_COMPARISON_NULL:	635	case FlowContext.IN_COMPARISON_NULL:
637	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	636	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
638	scope.problemReporter().localVariablePotentialNullReference(local, reference);	637	scope.problemReporter().reportPotentialNullReferenceProblem(local, reference);
639	return;	638	return;
640	}	639	}
641	break;	640	break;
642	case FlowContext.IN_COMPARISON_NON_NULL:	641	case FlowContext.IN_COMPARISON_NON_NULL:
643	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	642	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
644	scope.problemReporter().localVariablePotentialNullReference(local, reference);	643	scope.problemReporter().reportPotentialNullReferenceProblem(local, reference);
645	return;	644	return;
646	}	645	}
647	break;	646	break;
Lines 652-662 Link Here
652	break;	651	break;
653	case MAY_NULL :	652	case MAY_NULL :
654	if (flowInfo.isDefinitelyNull(local)) {	653	if (flowInfo.isDefinitelyNull(local)) {
655	scope.problemReporter().localVariableNullReference(local, reference);	654	scope.problemReporter().reportNullReferenceProblem(local, reference);
656	return;	655	return;
657	}	656	}
658	if (flowInfo.isPotentiallyNull(local)) {	657	if (flowInfo.isPotentiallyNull(local)) {
659	scope.problemReporter().localVariablePotentialNullReference(local, reference);	658	scope.problemReporter().reportPotentialNullReferenceProblem(local, reference);
660	return;	659	return;
661	}	660	}
662	break;	661	break;

Lines 3872-3877 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java (+12 lines)
3872	} while (scope != null);	3872	} while (scope != null);
3873	return lastMethodScope; // may answer null if no method around	3873	return lastMethodScope; // may answer null if no method around
3874	}	3874	}
		3875
		3876	public boolean isOuterMostMethodSynchronised() {
		3877	MethodScope outerMostMethodScope = this.outerMostMethodScope();
		3878	boolean isSynchronised = false;
		3879	if(outerMostMethodScope != null) {
		3880	AbstractMethodDeclaration referenceMethod = outerMostMethodScope.referenceMethod();
		3881	if(referenceMethod != null && referenceMethod.binding != null) {
		3882	isSynchronised = referenceMethod.binding.isSynchronized();
		3883	}
		3884	}
		3885	return isSynchronised;
		3886	}
3875		3887
3876	public int parameterCompatibilityLevel(MethodBinding method, TypeBinding[] arguments) {	3888	public int parameterCompatibilityLevel(MethodBinding method, TypeBinding[] arguments) {
3877	TypeBinding[] parameters = method.parameters;	3889	TypeBinding[] parameters = method.parameters;

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-51 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java (-8 / +9 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	boolean isSynchronised = scope.isOuterMostMethodSynchronised();
37	switch (nullStatus) {	38	switch (nullStatus) {
38	case FlowInfo.NULL :	39	case FlowInfo.NULL :
39	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	40	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
40	flowContext.recordUsingNullReference(scope, local, reference,	41	flowContext.recordUsingNullReference(scope, local, reference,
41	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);	42	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);
42	initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set	43	initsWhenTrue.markAsComparedEqualToNull(local, isSynchronised); // from thereon it is set
43	initsWhenFalse.markAsComparedEqualToNonNull(local); // from thereon it is set	44	initsWhenFalse.markAsComparedEqualToNonNull(local, isSynchronised ); // from thereon it is set
44	} else {	45	} else {
45	flowContext.recordUsingNullReference(scope, local, reference,	46	flowContext.recordUsingNullReference(scope, local, reference,
46	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);	47	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);
47	initsWhenTrue.markAsComparedEqualToNonNull(local); // from thereon it is set	48	initsWhenTrue.markAsComparedEqualToNonNull(local, isSynchronised); // from thereon it is set
48	initsWhenFalse.markAsComparedEqualToNull(local); // from thereon it is set	49	initsWhenFalse.markAsComparedEqualToNull(local, isSynchronised); // from thereon it is set
49	}	50	}
50	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	51	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
51	flowInfo.markedAsNullOrNonNullInAssertExpression(local);	52	flowInfo.markedAsNullOrNonNullInAssertExpression(local);
Lines 55-61 Link Here
55	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	56	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
56	flowContext.recordUsingNullReference(scope, local, reference,	57	flowContext.recordUsingNullReference(scope, local, reference,
57	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);	58	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);
58	initsWhenTrue.markAsComparedEqualToNonNull(local); // from thereon it is set	59	initsWhenTrue.markAsComparedEqualToNonNull(local, isSynchronised); // from thereon it is set
59	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	60	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
60	initsWhenTrue.markedAsNullOrNonNullInAssertExpression(local);	61	initsWhenTrue.markedAsNullOrNonNullInAssertExpression(local);
61	}	62	}

Lines 31-46 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/InstanceOfExpression.java (-5 / +6 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	boolean isSynchronised = currentScope.isOuterMostMethodSynchronised();
		40	initsWhenTrue.markAsComparedEqualToNonNull(variable, isSynchronised );
40	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	41	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
41	initsWhenTrue.markedAsNullOrNonNullInAssertExpression(local);	42	initsWhenTrue.markedAsNullOrNonNullInAssertExpression(variable);
42	}	43	}
43	flowContext.recordUsingNullReference(currentScope, local,	44	flowContext.recordUsingNullReference(currentScope, variable,
44	this.expression, FlowContext.CAN_ONLY_NULL \| FlowContext.IN_INSTANCEOF, flowInfo);	45	this.expression, FlowContext.CAN_ONLY_NULL \| FlowContext.IN_INSTANCEOF, flowInfo);
45	// no impact upon enclosing try context	46	// no impact upon enclosing try context
46	return FlowInfo.conditional(initsWhenTrue, flowInfo.copy());	47	return FlowInfo.conditional(initsWhenTrue, flowInfo.copy());

Lines 80-85 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TryStatement.java (-2 / +3 lines)
80	if (this.returnAddressVariable != null) { // TODO (philippe) if subroutine is escaping, unused	80	if (this.returnAddressVariable != null) { // TODO (philippe) if subroutine is escaping, unused
81	this.returnAddressVariable.useFlag = LocalVariableBinding.USED;	81	this.returnAddressVariable.useFlag = LocalVariableBinding.USED;
82	}	82	}
		83	boolean isSynchronised = currentScope.isOuterMostMethodSynchronised();
83	if (this.subRoutineStartLabel == null) {	84	if (this.subRoutineStartLabel == null) {
84	// no finally block -- this is a simplified copy of the else part	85	// no finally block -- this is a simplified copy of the else part
85	// process the try block in a context handling the local exceptions.	86	// process the try block in a context handling the local exceptions.
Lines 141-147 Link Here
141	// catch var is always set	142	// catch var is always set
142	LocalVariableBinding catchArg = this.catchArguments[i].binding;	143	LocalVariableBinding catchArg = this.catchArguments[i].binding;
143	catchInfo.markAsDefinitelyAssigned(catchArg);	144	catchInfo.markAsDefinitelyAssigned(catchArg);
144	catchInfo.markAsDefinitelyNonNull(catchArg);	145	catchInfo.markAsDefinitelyNonNull(catchArg, isSynchronised);
145	/*	146	/*
146	"If we are about to consider an unchecked exception handler, potential inits may have occured inside	147	"If we are about to consider an unchecked exception handler, potential inits may have occured inside
147	the try block that need to be detected , e.g.	148	the try block that need to be detected , e.g.
Lines 250-256 Link Here
250	// catch var is always set	251	// catch var is always set
251	LocalVariableBinding catchArg = this.catchArguments[i].binding;	252	LocalVariableBinding catchArg = this.catchArguments[i].binding;
252	catchInfo.markAsDefinitelyAssigned(catchArg);	253	catchInfo.markAsDefinitelyAssigned(catchArg);
253	catchInfo.markAsDefinitelyNonNull(catchArg);	254	catchInfo.markAsDefinitelyNonNull(catchArg, isSynchronised);
254	/*	255	/*
255	"If we are about to consider an unchecked exception handler, potential inits may have occured inside	256	"If we are about to consider an unchecked exception handler, potential inits may have occured inside
256	the try block that need to be detected , e.g.	257	the try block that need to be detected , e.g.

Lines 11-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/NullInfoRegistry.java (-23 / +59 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 53-60 Link Here
53	}	54	}
54	if (upstream.extra != null) {	55	if (upstream.extra != null) {
55	this.extra = new long[extraLength][];	56	this.extra = new long[extraLength][];
56	int length = upstream.extra[2].length;	57	int length = upstream.extra[0].length;
57	for (int i = 2; i < extraLength; i++) {	58	for (int i = 0; i < extraLength; i++) {
58	this.extra[i] = new long[length];	59	this.extra[i] = new long[length];
59	}	60	}
60	for (int i = 0; i < length; i++) {	61	for (int i = 0; i < length; i++) {
Lines 90-103 Link Here
90	if (other.extra != null) {	91	if (other.extra != null) {
91	if (this.extra == null) {	92	if (this.extra == null) {
92	this.extra = new long[extraLength][];	93	this.extra = new long[extraLength][];
93	for (int i = 2, length = other.extra[2].length; i < extraLength; i++) {	94	for (int i = 0, length = other.extra[0].length; i < extraLength; i++) {
94	System.arraycopy(other.extra[i], 0,	95	System.arraycopy(other.extra[i], 0,
95	(this.extra[i] = new long[length]), 0, length);	96	(this.extra[i] = new long[length]), 0, length);
96	}	97	}
97	} else {	98	} else {
98	int length = this.extra[2].length, otherLength = other.extra[2].length;	99	int length = this.extra[0].length, otherLength = other.extra[0].length;
99	if (otherLength > length) {	100	if (otherLength > length) {
100	for (int i = 2; i < extraLength; i++) {	101	for (int i = 0; i < extraLength; i++) {
101	System.arraycopy(this.extra[i], 0,	102	System.arraycopy(this.extra[i], 0,
102	(this.extra[i] = new long[otherLength]), 0, length);	103	(this.extra[i] = new long[otherLength]), 0, length);
103	System.arraycopy(other.extra[i], length,	104	System.arraycopy(other.extra[i], length,
Lines 106-112 Link Here
106	} else if (otherLength < length) {	107	} else if (otherLength < length) {
107	length = otherLength;	108	length = otherLength;
108	}	109	}
109	for (int i = 2; i < extraLength; i++) {	110	for (int i = 0; i < extraLength; i++) {
110	for (int j = 0; j < length; j++) {	111	for (int j = 0; j < length; j++) {
111	this.extra[i][j] \|= other.extra[i][j];	112	this.extra[i][j] \|= other.extra[i][j];
112	}	113	}
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, boolean isSynchronised) {
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	if (isSynchronised) {
		127	position = local.id;
		128	} else {
		129	this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL, isSynchronised);
		130	return;
		131	}
		132	} else {
		133	position = local.id + this.maxFieldCount;
		134	}
124	// position is zero-based	135	// position is zero-based
125	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	136	if (position < BitCacheSize) { // use bits
126	// set protected non null	137	// set protected non null
127	this.nullBit1 \|= (1L << position);	138	this.nullBit1 \|= (1L << position);
128	if (COVERAGE_TEST_FLAG) {	139	if (COVERAGE_TEST_FLAG) {
Lines 137-150 Link Here
137	if (this.extra == null) {	148	if (this.extra == null) {
138	int length = vectorIndex + 1;	149	int length = vectorIndex + 1;
139	this.extra = new long[extraLength][];	150	this.extra = new long[extraLength][];
140	for (int j = 2; j < extraLength; j++) {	151	for (int j = 0; j < extraLength; j++) {
141	this.extra[j] = new long[length];	152	this.extra[j] = new long[length];
142	}	153	}
143	}	154	}
144	else {	155	else {
145	int oldLength; // might need to grow the arrays	156	int oldLength; // might need to grow the arrays
146	if (vectorIndex >= (oldLength = this.extra[2].length)) {	157	if (vectorIndex >= (oldLength = this.extra[2].length)) {
147	for (int j = 2; j < extraLength; j++) {	158	for (int j = 0; j < extraLength; j++) {
148	System.arraycopy(this.extra[j], 0,	159	System.arraycopy(this.extra[j], 0,
149	(this.extra[j] = new long[vectorIndex + 1]), 0,	160	(this.extra[j] = new long[vectorIndex + 1]), 0,
150	oldLength);	161	oldLength);
Lines 161-173 Link Here
161	}	172	}
162	}	173	}
163		174
164	public void markAsDefinitelyNonNull(LocalVariableBinding local) {	175	public void markAsDefinitelyNonNull(VariableBinding local, boolean isSynchronised) {
165	// protected from non-object locals in calling methods	176	// protected from non-object locals in calling methods
166	if (this != DEAD_END) {	177	if (this != DEAD_END) {
167	this.tagBits \|= NULL_FLAG_MASK;	178	this.tagBits \|= NULL_FLAG_MASK;
168	int position;	179	int position;
169	// position is zero-based	180	// position is zero-based
170	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	181	if (local instanceof FieldBinding) {
		182	if (isSynchronised) {
		183	position = local.id;
		184	} else {
		185	this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL, isSynchronised);
		186	return;
		187	}
		188	} else {
		189	position = local.id + this.maxFieldCount;
		190	}
		191	if (position < BitCacheSize) { // use bits
171	// set assigned non null	192	// set assigned non null
172	this.nullBit3 \|= (1L << position);	193	this.nullBit3 \|= (1L << position);
173	if (COVERAGE_TEST_FLAG) {	194	if (COVERAGE_TEST_FLAG) {
Lines 182-195 Link Here
182	if (this.extra == null) {	203	if (this.extra == null) {
183	int length = vectorIndex + 1;	204	int length = vectorIndex + 1;
184	this.extra = new long[extraLength][];	205	this.extra = new long[extraLength][];
185	for (int j = 2; j < extraLength; j++) {	206	for (int j = 0; j < extraLength; j++) {
186	this.extra[j] = new long[length];	207	this.extra[j] = new long[length];
187	}	208	}
188	}	209	}
189	else {	210	else {
190	int oldLength; // might need to grow the arrays	211	int oldLength; // might need to grow the arrays
191	if (vectorIndex >= (oldLength = this.extra[2].length)) {	212	if (vectorIndex >= (oldLength = this.extra[2].length)) {
192	for (int j = 2; j < extraLength; j++) {	213	for (int j = 0; j < extraLength; j++) {
193	System.arraycopy(this.extra[j], 0,	214	System.arraycopy(this.extra[j], 0,
194	(this.extra[j] = new long[vectorIndex + 1]), 0,	215	(this.extra[j] = new long[vectorIndex + 1]), 0,
195	oldLength);	216	oldLength);
Lines 207-219 Link Here
207	}	228	}
208	// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either	229	// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either
209	// PREMATURE project protected non null onto something else	230	// PREMATURE project protected non null onto something else
210	public void markAsDefinitelyNull(LocalVariableBinding local) {	231	public void markAsDefinitelyNull(VariableBinding local, boolean isSynchronised) {
211	// protected from non-object locals in calling methods	232	// protected from non-object locals in calling methods
212	if (this != DEAD_END) {	233	if (this != DEAD_END) {
213	this.tagBits \|= NULL_FLAG_MASK;	234	this.tagBits \|= NULL_FLAG_MASK;
214	int position;	235	int position;
		236	if (local instanceof FieldBinding) {
		237	if (isSynchronised) {
		238	position = local.id;
		239	} else {
		240	this.markNullStatus(local, FlowInfo.POTENTIALLY_NULL, isSynchronised);
		241	return;
		242	}
		243	} else {
		244	position = local.id + this.maxFieldCount;
		245	}
215	// position is zero-based	246	// position is zero-based
216	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	247	if (position < BitCacheSize) { // use bits
217	// set assigned null	248	// set assigned null
218	this.nullBit2 \|= (1L << position);	249	this.nullBit2 \|= (1L << position);
219	if (COVERAGE_TEST_FLAG) {	250	if (COVERAGE_TEST_FLAG) {
Lines 228-241 Link Here
228	if (this.extra == null) {	259	if (this.extra == null) {
229	int length = vectorIndex + 1;	260	int length = vectorIndex + 1;
230	this.extra = new long[extraLength][];	261	this.extra = new long[extraLength][];
231	for (int j = 2; j < extraLength; j++) {	262	for (int j = 0; j < extraLength; j++) {
232	this.extra[j] = new long[length];	263	this.extra[j] = new long[length];
233	}	264	}
234	}	265	}
235	else {	266	else {
236	int oldLength; // might need to grow the arrays	267	int oldLength; // might need to grow the arrays
237	if (vectorIndex >= (oldLength = this.extra[2].length)) {	268	if (vectorIndex >= (oldLength = this.extra[2].length)) {
238	for (int j = 2; j < extraLength; j++) {	269	for (int j = 0; j < extraLength; j++) {
239	System.arraycopy(this.extra[j], 0,	270	System.arraycopy(this.extra[j], 0,
240	(this.extra[j] = new long[vectorIndex + 1]), 0,	271	(this.extra[j] = new long[vectorIndex + 1]), 0,
241	oldLength);	272	oldLength);
Lines 252-264 Link Here
252	}	283	}
253	}	284	}
254		285
255	public void markAsDefinitelyUnknown(LocalVariableBinding local) {	286	public void markAsDefinitelyUnknown(VariableBinding local) {
256	// protected from non-object locals in calling methods	287	// protected from non-object locals in calling methods
257	if (this != DEAD_END) {	288	if (this != DEAD_END) {
258	this.tagBits \|= NULL_FLAG_MASK;	289	this.tagBits \|= NULL_FLAG_MASK;
259	int position;	290	int position;
		291	if (local instanceof FieldBinding) {
		292	position = local.id;
		293	} else {
		294	position = local.id + this.maxFieldCount;
		295	}
260	// position is zero-based	296	// position is zero-based
261	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	297	if (position < BitCacheSize) { // use bits
262	// set assigned unknown	298	// set assigned unknown
263	this.nullBit4 \|= (1L << position);	299	this.nullBit4 \|= (1L << position);
264	if (COVERAGE_TEST_FLAG) {	300	if (COVERAGE_TEST_FLAG) {
Lines 273-286 Link Here
273	if (this.extra == null) {	309	if (this.extra == null) {
274	int length = vectorIndex + 1;	310	int length = vectorIndex + 1;
275	this.extra = new long[extraLength][];	311	this.extra = new long[extraLength][];
276	for (int j = 2; j < extraLength; j++) {	312	for (int j = 0; j < extraLength; j++) {
277	this.extra[j] = new long[length];	313	this.extra[j] = new long[length];
278	}	314	}
279	}	315	}
280	else {	316	else {
281	int oldLength; // might need to grow the arrays	317	int oldLength; // might need to grow the arrays
282	if (vectorIndex >= (oldLength = this.extra[2].length)) {	318	if (vectorIndex >= (oldLength = this.extra[2].length)) {
283	for (int j = 2; j < extraLength; j++) {	319	for (int j = 0; j < extraLength; j++) {
284	System.arraycopy(this.extra[j], 0,	320	System.arraycopy(this.extra[j], 0,
285	(this.extra[j] = new long[vectorIndex + 1]), 0,	321	(this.extra[j] = new long[vectorIndex + 1]), 0,
286	oldLength);	322	oldLength);

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 65-71 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/NullReferenceImplTransformations.java (-4 / +4 lines)
65	UnconditionalFlowInfo output(UnconditionalFlowInfo input,	65	UnconditionalFlowInfo output(UnconditionalFlowInfo input,
66	TestLocalVariableBinding local) {	66	TestLocalVariableBinding local) {
67	UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();	67	UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();
68	result.markAsComparedEqualToNonNull(local);	68	result.markAsComparedEqualToNonNull(local, false);
69	return result;	69	return result;
70	}	70	}
71	},	71	},
Lines 108-114 Link Here
108	UnconditionalFlowInfo output(UnconditionalFlowInfo input,	108	UnconditionalFlowInfo output(UnconditionalFlowInfo input,
109	TestLocalVariableBinding local) {	109	TestLocalVariableBinding local) {
110	UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();	110	UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();
111	result.markAsComparedEqualToNull(local);	111	result.markAsComparedEqualToNull(local, false);
112	return result;	112	return result;
113	}	113	}
114	},	114	},
Lines 151-157 Link Here
151	UnconditionalFlowInfo output(UnconditionalFlowInfo input,	151	UnconditionalFlowInfo output(UnconditionalFlowInfo input,
152	TestLocalVariableBinding local) {	152	TestLocalVariableBinding local) {
153	UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();	153	UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();
154	result.markAsDefinitelyNonNull(local);	154	result.markAsDefinitelyNonNull(local, false);
155	return result;	155	return result;
156	}	156	}
157	},	157	},
Lines 195-201 Link Here
195	UnconditionalFlowInfo output(UnconditionalFlowInfo input,	195	UnconditionalFlowInfo output(UnconditionalFlowInfo input,
196	TestLocalVariableBinding local) {	196	TestLocalVariableBinding local) {
197	UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();	197	UnconditionalFlowInfo result = (UnconditionalFlowInfo)input.copy();
198	result.markAsDefinitelyNull(local);	198	result.markAsDefinitelyNull(local, false);
199	return result;	199	return result;
200	}	200	}
201	},	201	},

Lines 36-42 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/NullReferenceTest.java (-36 / +431 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[] { "test0002_simple_field" };
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	"Null pointer access: The field o can only 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 fields that are protected against concurrent access
13875	// behave as locals when no call to further methods can affect them
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	" Object o2;\n" +
13884	" Object o3;\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	" o2 = null;\n" +
13895	" if (o2 != null) {\n" +
13896	" }\n" +
13897	" else {\n" +
13898	" o2.toString();\n" +
13899	" }\n" +
13900	" o3 = new Object();\n" +
13901	" if (o3 == null) {\n" +
13902	" }\n" +
13903	" else {\n" +
13904	" o3.toString();\n" +
13905	" }\n" +
13906	" }\n" +
13907	" void foo1() {\n" +
13908	" o.toString();\n" +
13909	" }\n" +
13910	"}\n"},
13911	"----------\n" +
13912	"1. ERROR in X.java (at line 8)\n" +
13913	" if (o == null) {\n" +
13914	" ^\n" +
13915	"Redundant null check: The field o can only be null at this location\n" +
13916	"----------\n" +
13917	"2. ERROR in X.java (at line 9)\n" +
13918	" o.toString();\n" +
13919	" ^\n" +
13920	"Null pointer access: The field o can only be null at this location\n" +
13921	"----------\n" +
13922	"3. ERROR in X.java (at line 12)\n" +
13923	" if (o1 == null) {\n" +
13924	" ^^\n" +
13925	"Null comparison always yields false: The field o1 cannot be null at this location\n" +
13926	"----------\n" +
13927	"4. WARNING in X.java (at line 12)\n" +
13928	" if (o1 == null) {\n" +
13929	" o1.toString();\n" +
13930	" }\n" +
13931	" ^^^^^^^^^^^^^^^^^^^^^^^\n" +
13932	"Dead code\n" +
13933	"----------\n" +
13934	"5. ERROR in X.java (at line 16)\n" +
13935	" if (o2 != null) {\n" +
13936	" ^^\n" +
13937	"Null comparison always yields false: The field o2 can only be null at this location\n" +
13938	"----------\n" +
13939	"6. WARNING in X.java (at line 16)\n" +
13940	" if (o2 != null) {\n" +
13941	" }\n" +
13942	" ^^^^^\n" +
13943	"Dead code\n" +
13944	"----------\n" +
13945	"7. ERROR in X.java (at line 19)\n" +
13946	" o2.toString();\n" +
13947	" ^^\n" +
13948	"Null pointer access: The field o2 can only be null at this location\n" +
13949	"----------\n" +
13950	"8. ERROR in X.java (at line 22)\n" +
13951	" if (o3 == null) {\n" +
13952	" ^^\n" +
13953	"Null comparison always yields false: The field o3 cannot be null at this location\n" +
13954	"----------\n" +
13955	"9. WARNING in X.java (at line 22)\n" +
13956	" if (o3 == null) {\n" +
13957	" }\n" +
13958	" ^^^^^\n" +
13959	"Dead code\n" +
13960	"----------\n"
13961	);
13962	}
13963
13964	// null analysis -- test redundant instanceof warning for static final field
13965	public void testBug247564d() {
13966	this.runNegativeTest(
13967	new String[] {
13968	"X.java",
13969	"public class X {\n" +
13970	" static final Object o = null;\n" +
13971	" static final Object o1 = new Object();\n" +
13972	" void foo() {\n" +
13973	" if (o instanceof String) {}\n" +
13974	" if (o1 instanceof String) {}\n" +
13975	" }\n" +
13976	"}\n"},
13977	"----------\n" +
13978	"1. ERROR in X.java (at line 5)\n" +
13979	" if (o instanceof String) {}\n" +
13980	" ^\n" +
13981	"instanceof always yields false: The field o can only be null at this location\n" +
13982	"----------\n"
13983	);
13984	}
13985
13986	// null analysis -- test redundant instanceof warning for fields in synchronised method
13987	public void testBug247564d_1() {
13988	this.runNegativeTest(
13989	new String[] {
13990	"X.java",
13991	"public class X {\n" +
13992	" Object o;\n" +
13993	" Object o1;\n" +
13994	" synchronized void foo() {\n" +
13995	" if (o == null && o instanceof String) {}\n" +
13996	" o1 = null;\n" +
13997	" if (o1 instanceof String) {}\n" +
13998	" }\n" +
13999	" void foo1() {\n" +
14000	" if (o == null && o instanceof String) {}\n" +
14001	" o1 = null;\n" +
14002	" if (o1 instanceof String) {}\n" +
14003	" }\n" +
14004	"}\n"},
14005	"----------\n" +
14006	"1. ERROR in X.java (at line 5)\n" +
14007	" if (o == null && o instanceof String) {}\n" +
14008	" ^\n" +
14009	"instanceof always yields false: The field o can only be null at this location\n" +
14010	"----------\n" +
14011	"2. ERROR in X.java (at line 7)\n" +
14012	" if (o1 instanceof String) {}\n" +
14013	" ^^\n" +
14014	"instanceof always yields false: The field o1 can only be null at this location\n" +
14015	"----------\n"
14016	);
14017	}
14018
14019	// null analysis -- test redundant instanceof warning for fields in synchronised method
14020	public void testBug247564e() {
14021	this.runNegativeTest(
14022	new String[] {
14023	"X.java",
14024	"public class X {\n" +
14025	" Object o;\n" +
14026	" synchronized void foo() {\n" +
14027	" if (o == null) { o = null;}\n" +
14028	" }\n" +
14029	" void foo1() {\n" +
14030	" if (o == null) { o = null;}\n" +
14031	" }\n" +
14032	"}\n"},
14033	"----------\n" +
14034	"1. ERROR in X.java (at line 4)\n" +
14035	" if (o == null) { o = null;}\n" +
14036	" ^\n" +
14037	"Redundant assignment: The field o can only be null at this location\n" +
14038	"----------\n"
14039	);
14040	}
14041
14042	// null analysis -- test redundant instanceof warning for fields in synchronised method
14043	public void testBug247564e_1() {
14044	this.runNegativeTest(
14045	new String[] {
14046	"X.java",
14047	"public class X {\n" +
14048	" Object o;\n" +
14049	" synchronized void foo() {\n" +
14050	" o = null;" +
14051	" do {\n" +
14052	" if (o != null) return;\n" +
14053	" o = null;\n" +
14054	" } while (true);\n" +
14055	" }\n" +
14056	"}"},
14057	"----------\n" +
14058	"1. ERROR in X.java (at line 5)\n" +
14059	" if (o != null) return;\n" +
14060	" ^\n" +
14061	"Null comparison always yields false: The field o can only be null at this location\n" +
14062	"----------\n" +
14063	"2. ERROR in X.java (at line 6)\n" +
14064	" o = null;\n" +
14065	" ^\n" +
14066	"Redundant assignment: The field o can only be null at this location\n" +
14067	"----------\n",
14068	JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
14069	}
14070
13676	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=332637	14071	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=332637
13677	// Dead Code detection removing code that isn't dead	14072	// Dead Code detection removing code that isn't dead
13678	public void testBug332637() {	14073	public void testBug332637() {