Attachment #188023 for bug #247564

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




    /** @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 40-46 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java (-1 / +10 lines)
40	// record setting a variable: various scenarii are possible, setting an array reference,	40	// record setting a variable: various scenarii are possible, setting an array reference,
41	// a field reference, a blank final field reference, a field of an enclosing instance or	41	// a field reference, a blank final field reference, a field of an enclosing instance or
42	// just a local variable.	42	// just a local variable.
43	LocalVariableBinding local = this.lhs.localVariableBinding();	43	VariableBinding local = this.lhs.variableBinding();
44	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	44	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
45	this.expression.checkNPE(currentScope, flowContext, flowInfo);	45	this.expression.checkNPE(currentScope, flowContext, flowInfo);
46	}	46	}
Lines 59-64 Link Here
59	flowInfo.markNullStatus(local, nullStatus);	59	flowInfo.markNullStatus(local, nullStatus);
60	if (flowContext.initsOnFinally != null)	60	if (flowContext.initsOnFinally != null)
61	flowContext.initsOnFinally.markNullStatus(local, nullStatus);	61	flowContext.initsOnFinally.markNullStatus(local, nullStatus);
		62	if (local instanceof FieldBinding && local.isFinal() && ((FieldBinding) local).isStatic()) {
		63	// static final field being assigned. Record its null status for future reference
		64	// since the flowInfo from a constructor or static block wont be available in a method
		65	FieldBinding fieldBinding = (FieldBinding) local;
		66	fieldBinding.setNullStatusForStaticFinalField(nullStatus);
		67	}
62	}	68	}
63	return flowInfo;	69	return flowInfo;
64	}	70	}
Lines 208-211 Link Here
208	public LocalVariableBinding localVariableBinding() {	214	public LocalVariableBinding localVariableBinding() {
209	return this.lhs.localVariableBinding();	215	return this.lhs.localVariableBinding();
210	}	216	}
		217	public VariableBinding variableBinding() {
		218	return this.lhs.variableBinding();
		219	}
211	}	220	}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (-1 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 36-41 Link Here
36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);	36	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);
37	}	37	}
38	}	38	}
		39	// don't let the flow info collected for fields from this block persist.
		40	flowInfo.resetNullInfoForFields();
39	return flowInfo;	41	return flowInfo;
40	}	42	}
41	/**	43	/**

Lines 32-37 Link Here

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




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

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




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

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

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

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

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

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

Lines 74-79 Link Here

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




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

import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;

public class FieldReference extends Reference implements InvocationSite {


	}
	visitor.endVisit(this, scope);
}

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

}




}

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

Lines 95-100 Link Here

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




	return null;
}

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

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

Lines 56-62 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Statement.java (-1 / +1 lines)
56	public static final int COMPLAINED_UNREACHABLE = 2;	56	public static final int COMPLAINED_UNREACHABLE = 2;
57		57
58	/** Empty hook for checking null status against declaration using null annotations, once this will be supported. */	58	/** Empty hook for checking null status against declaration using null annotations, once this will be supported. */
59	protected int checkAgainstNullAnnotation(BlockScope currentScope, LocalVariableBinding local, int nullStatus) {	59	protected int checkAgainstNullAnnotation(BlockScope currentScope, VariableBinding local, int nullStatus) {
60	return nullStatus;	60	return nullStatus;
61	}	61	}
62		62




	public MethodScope staticInitializerScope;
	public boolean ignoreFurtherInvestigation = false;
	public int maxFieldCount;
//	public int maxFieldCountForFlowInfo;	// cumulative count of fields in this type and enclosing types
	public int declarationSourceStart;
	public int declarationSourceEnd;
	public int bodyStart;


	// 1.5 support
	public TypeParameter[] typeParameters;
	private int maxFieldCountForFlowInfo;

public TypeDeclaration(CompilationResult compilationResult){
	this.compilationResult = compilationResult;

			localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));
		}
		manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
		
		

//		if (this.enclosingType != null) {
//			this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
//		} else {
//			this.maxFieldCountForFlowInfo = this.maxFieldCount;
//		}
		updateMaxFieldCount(); // propagate down the max field count
		
//		if ((this.binding.tagBits & ASTNode.IsLocalType) != 0) {
//			// non-anonymous local type can declare its fields. So change the cumulativeFieldCount
//			UnconditionalFlowInfo unconFlowInfo = flowInfo.unconditionalInits();
//			int tempCount = unconFlowInfo.maxFieldCount;
//			unconFlowInfo.maxFieldCount = this.scope.cumulativeFieldCount;
//			internalAnalyseCode(flowContext, flowInfo);
//			unconFlowInfo.maxFieldCount = tempCount;
//		} else {

			internalAnalyseCode(flowContext, flowInfo);
//		}
	} catch (AbortType e) {
		this.ignoreFurtherInvestigation = true;
	}

	if (this.ignoreFurtherInvestigation)
		return;
	try {
		
		
//		if (this.enclosingType == null) {
//			this.maxFieldCountForFlowInfo = this.maxFieldCount;
//		} else {
//			this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
//		}
		// propagate down the max field count
		updateMaxFieldCount();
		internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCount));

			localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));
		}
		manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
		
		
		
//		if (this.enclosingType == null) {
//			this.maxFieldCountForFlowInfo = this.maxFieldCount;
//		} else {
//			this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
//		}
		updateMaxFieldCount(); // propagate down the max field count
		//flowInfo.unconditionalInits().maxFieldCount = this.maxFieldCountForFlowInfo;
		UnconditionalFlowInfo unconFlowInfo = flowInfo.unconditionalInits();
		//int tempCount = unconFlowInfo.maxFieldCount;
		//unconFlowInfo.maxFieldCount = this.scope.cumulativeFieldCount;
		internalAnalyseCode(flowContext, flowInfo);
		//flowInfo.resetNullInfoForFields();
		//unconFlowInfo.maxFieldCount = tempCount;
	} catch (AbortType e) {
		this.ignoreFurtherInvestigation = true;
	}

	if (this.ignoreFurtherInvestigation)
		return;
	try {
//		if (this.enclosingType == null) {
//			this.maxFieldCountForFlowInfo = this.maxFieldCount;
//		} else {
//			this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
//		}
		internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCount));
	} catch (AbortType e) {
		this.ignoreFurtherInvestigation = true;

				// branch, since the previous initializer already got the blame.
				if (staticFieldInfo == FlowInfo.DEAD_END) {
					this.staticInitializerScope.problemReporter().initializerMustCompleteNormally(field);
					staticFieldInfo = FlowInfo.initial(this.scope.cumulativeFieldCount).setReachMode(FlowInfo.UNREACHABLE);
				}
			} else {
				if ((nonStaticFieldInfo.tagBits & FlowInfo.UNREACHABLE) != 0)

				// branch, since the previous initializer already got the blame.
				if (nonStaticFieldInfo == FlowInfo.DEAD_END) {
					this.initializerScope.problemReporter().initializerMustCompleteNormally(field);
					nonStaticFieldInfo = FlowInfo.initial(this.scope.cumulativeFieldCount).setReachMode(FlowInfo.UNREACHABLE);
				}
			}
		}

	}
	if (this.methods != null) {
		UnconditionalFlowInfo outerInfo = flowInfo.unconditionalFieldLessCopy();
		boolean isLocal = (this.binding.tagBits & ASTNode.IsLocalType) != 0;
		//int fieldOffset = isLocal ? this.scope.cumulativeFieldCount : this.maxFieldCount;
		//int fieldStart = isLocal ? this.scope.localTypeFieldIdStart : 0;
		FlowInfo constructorInfo = nonStaticFieldInfo.unconditionalInits().discardNonFieldInitializations(0).addInitializationsFrom(outerInfo);
		for (int i = 0, count = this.methods.length; i < count; i++) {
			AbstractMethodDeclaration method = this.methods[i];
			if (method.ignoreFurtherInvestigation)

					method.analyseCode(
						this.scope,
						staticInitializerContext,
						staticFieldInfo.unconditionalInits().discardNonFieldInitializations(0).addInitializationsFrom(outerInfo));
				} else { // constructor
					((ConstructorDeclaration)method).analyseCode(this.scope, initializerContext, constructorInfo.copy(), flowInfo.reachMode());
				}

				this.typeParameters[i].resolve(this.scope);
			}
		}
		
		// field count from supertypes should be included in maxFieldCount,
		// so that a field from supertype doesn't end up with same id as a local variable
		// in a method being analyzed.
		int superFieldsCount = 0;
		ReferenceBinding superClassBinding = sourceType.superclass;
		while (superClassBinding != null) {
			FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
			if (unResolvedFields != null) {
				superFieldsCount += unResolvedFields.length;
			}
			superFieldsCount += findFieldCountFromSuperInterfaces(superClassBinding.superInterfaces());
			superClassBinding = superClassBinding.superclass();
		}
		ReferenceBinding[] superInterfacesBinding = this.binding.superInterfaces;
		superFieldsCount += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		this.scope.cumulativeFieldCount += superFieldsCount;
		if (this.fields != null) {
			for (int i = 0, count = this.fields.length; i < count; i++) {
				FieldDeclaration field = this.fields[i];

							this.ignoreFurtherInvestigation = true;
							continue;
						}
						field.binding.id += superFieldsCount;
						if (needSerialVersion
								&& ((fieldBinding.modifiers & (ClassFileConstants.AccStatic | ClassFileConstants.AccFinal)) == (ClassFileConstants.AccStatic | ClassFileConstants.AccFinal))
								&& CharOperation.equals(TypeConstants.SERIALVERSIONUID, fieldBinding.name)

				field.resolve(field.isStatic() ? this.staticInitializerScope : this.initializerScope);
			}
		}
		
//		if (this.maxFieldCount < localMaxFieldCount) {
//			this.maxFieldCount = localMaxFieldCount;
//		}
		this.maxFieldCount = this.scope.cumulativeFieldCount;
		if (this.memberTypes != null) {
			for (int i = 0, count = this.memberTypes.length; i < count; i++) {
				this.memberTypes[i].resolve(this.scope);
			}
		}
//		if (this.memberTypes != null) {
//			for (int i = 0, count = this.memberTypes.length; i < count; i++) {
//				this.memberTypes[i].maxFieldCount += this.maxFieldCount;
//			}
//		}
       
//		if (this.enclosingType != null)
//			this.maxFieldCount += this.enclosingType.maxFieldCount;
	
		if (needSerialVersion) {
			//check that the current type doesn't extend javax.rmi.CORBA.Stub
			TypeBinding javaxRmiCorbaStub = this.scope.getType(TypeConstants.JAVAX_RMI_CORBA_STUB, 4);

	}
}

private int findFieldCountFromSuperInterfaces(ReferenceBinding[] superinterfaces) {
	int numOfFields = 0;
	if (superinterfaces == null)
		return numOfFields ;
	for (int i = 0; i < superinterfaces.length; i++) {
		numOfFields += superinterfaces[i].fieldCount();
		numOfFields += findFieldCountFromSuperInterfaces(superinterfaces[i].superInterfaces());		
	}
	return numOfFields;
}

/**
 * Resolve a local type declaration
 */

	} else {
		this.maxFieldCount = outerMostType.maxFieldCount; // down
	}
	
}

//int getMaxFieldCountForFlowInfo() {
//	int maxFieldCountForFlowInfo = 0;
//	if (this.binding == null)
//		return maxFieldCountForFlowInfo; // error scenario
//	ReferenceBinding superClassBinding = this.binding.superclass;
//	while (superClassBinding != null) {
//		FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
//		if (unResolvedFields != null) {
//			this.maxFieldCount += unResolvedFields.length;
//		}
//		superClassBinding = superClassBinding.superclass();
//	}
//	ReferenceBinding[] superInterfacesBinding = this.binding.superInterfaces;
//	maxFieldCountForFlowInfo += findFieldCountFromSuperInterfaces(superInterfacesBinding);
//	if (this.enclosingType != null) {
//		maxFieldCountForFlowInfo += this.enclosingType.maxFieldCount;
//	}
//	return maxFieldCountForFlowInfo;
//	
//}

/**
 * Returns whether the type is a secondary one or not.
 */





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

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

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

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

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

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

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

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

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

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

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

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

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

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

	this.initsWhenFalse.markAsDefinitelyAssigned(local);
}

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

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

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

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

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

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

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

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

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

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

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




	VariableBinding[] finalVariables;
	int assignCount;

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

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

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

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

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

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

		return true;
	}

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

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

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

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

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

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

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

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

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

		}
	}

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

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




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

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

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

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

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

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

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




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

public abstract class FlowInfo {


	}

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

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

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

/**

	public abstract boolean isDefinitelyAssigned(LocalVariableBinding local);

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

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

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

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

	 abstract public boolean isPotentiallyAssigned(LocalVariableBinding field);

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

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

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

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

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

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

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

	/**
	 * Record a field got definitely assigned.

	abstract public void markAsDefinitelyAssigned(FieldBinding field);

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

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

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

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

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

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

	/**
	 * Record a local got definitely assigned.

	abstract public void markAsDefinitelyAssigned(LocalVariableBinding local);

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

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

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

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

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




	VariableBinding finalVariables[];
	int assignCount = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

		return true;
	}

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

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

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

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

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

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

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




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

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

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

	return this;
}

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

	}
}

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

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

	}
}

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

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

	}
}

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

	}
}

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




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

/**
 * Record initialization status during definite assignment analysis

	return this;
}

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

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

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

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

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

 * Remove local variables information from this flow info and return this.
 * @return this, deprived from any local variable information
 */
public UnconditionalFlowInfo discardNonFieldInitializations(int fieldStart) {
	int limit = this.maxFieldCount;
	if (limit < BitCacheSize) {
		long mask = (1L << limit)-1;
		//mask = mask & (-1L << fieldStart);
		this.definiteInits &= mask;
		this.potentialInits &= mask;
		this.nullBit1 &= mask;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	}
}

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

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

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

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

	}
}

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

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

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

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

	}
}

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

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

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

	}
}

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

	}
}

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

	return this;
}

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

	this.nullStatusChangedInAssert[position] = 1;
}

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




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

	// update local variable binding
	binding.declaringScope = this;
	binding.id = outerMostMethodScope().analysisIndex++;
//	int cumulativeMaxFieldCounts = 0;
	ClassScope outerClassScope = this.enclosingClassScope();
//	TypeDeclaration typeDeclaration = (outerClassScope != null)? outerClassScope.referenceType() :  null;
//	while (typeDeclaration != null) {
//		cumulativeMaxFieldCounts += typeDeclaration.maxFieldCount;
//		typeDeclaration = typeDeclaration.enclosingType;
//	}
	if (outerClassScope != null) {
		//if (outerClassScope.referenceContext.binding != null && ((outerClassScope.referenceContext.binding.tagBits & ASTNode.IsLocalType) != 0))
			//binding.id += outerClassScope.cumulativeFieldCount;
	}
	
	// share the outermost method scope analysisIndex
}


Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java (-2 / +39 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 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 34-44 Link Here
34	public TypeDeclaration referenceContext;	34	public TypeDeclaration referenceContext;
35	public TypeReference superTypeReference;	35	public TypeReference superTypeReference;
36	java.util.ArrayList deferredBoundChecks;	36	java.util.ArrayList deferredBoundChecks;
		37	public int cumulativeFieldCount; // cumulative field count from all enclosing types, used to build unique field id's for member types.
		38	public int localTypeFieldIdStart;
37		39
38	public ClassScope(Scope parent, TypeDeclaration context) {	40	public ClassScope(Scope parent, TypeDeclaration context) {
39	super(Scope.CLASS_SCOPE, parent);	41	super(Scope.CLASS_SCOPE, parent);
40	this.referenceContext = context;	42	this.referenceContext = context;
41	this.deferredBoundChecks = null; // initialized if required	43	this.deferredBoundChecks = null; // initialized if required
		44	this.localTypeFieldIdStart = this.cumulativeFieldCount = 0;
42	}	45	}
43		46
44	void buildAnonymousTypeBinding(SourceTypeBinding enclosingType, ReferenceBinding supertype) {	47	void buildAnonymousTypeBinding(SourceTypeBinding enclosingType, ReferenceBinding supertype) {
Lines 75-80 Link Here
75	}	78	}
76	}	79	}
77	}	80	}
		81	this.cumulativeFieldCount += outerMostMethodScope().analysisIndex;
		82	this.localTypeFieldIdStart = outerMostMethodScope().analysisIndex;
78	connectMemberTypes();	83	connectMemberTypes();
79	buildFieldsAndMethods();	84	buildFieldsAndMethods();
80	anonymousType.faultInTypesForFieldsAndMethods();	85	anonymousType.faultInTypesForFieldsAndMethods();
Lines 104-109 Link Here
104	FieldBinding[] fieldBindings = new FieldBinding[count];	109	FieldBinding[] fieldBindings = new FieldBinding[count];
105	HashtableOfObject knownFieldNames = new HashtableOfObject(count);	110	HashtableOfObject knownFieldNames = new HashtableOfObject(count);
106	count = 0;	111	count = 0;
		112	ClassScope enclosingClass = this.enclosingClassScope();
		113	if (enclosingClass != null) {
		114	this.cumulativeFieldCount += enclosingClass.cumulativeFieldCount;
		115	}
		116	// SourceTypeBinding enclosingSourceType = this.enclosingSourceType();
		117	// if (enclosingSourceType != null) {
		118	// ReferenceBinding superClassBinding = sourceType.superclass;
		119	// while (superClassBinding != null) {
		120	// FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
		121	// if (unResolvedFields != null) {
		122	// this.cumulativeFieldCount += unResolvedFields.length;
		123	// }
		124	// superClassBinding = superClassBinding.superclass();
		125	// }
		126	// ReferenceBinding[] superInterfacesBinding = enclosingSourceType.superInterfaces;
		127	// this.cumulativeFieldCount += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		128	// }
		129
107	for (int i = 0; i < size; i++) {	130	for (int i = 0; i < size; i++) {
108	FieldDeclaration field = fields[i];	131	FieldDeclaration field = fields[i];
109	if (field.getKind() == AbstractVariableDeclaration.INITIALIZER) {	132	if (field.getKind() == AbstractVariableDeclaration.INITIALIZER) {
Lines 111-117 Link Here
111	// now this error reporting is moved into the parser itself. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=212713	134	// now this error reporting is moved into the parser itself. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=212713
112	} else {	135	} else {
113	FieldBinding fieldBinding = new FieldBinding(field, null, field.modifiers \| ExtraCompilerModifiers.AccUnresolved, sourceType);	136	FieldBinding fieldBinding = new FieldBinding(field, null, field.modifiers \| ExtraCompilerModifiers.AccUnresolved, sourceType);
114	fieldBinding.id = count;	137	fieldBinding.id = count + this.cumulativeFieldCount;
115	// field's type will be resolved when needed for top level types	138	// field's type will be resolved when needed for top level types
116	checkAndSetModifiersForField(fieldBinding, field);	139	checkAndSetModifiersForField(fieldBinding, field);
117		140
Lines 139-144 Link Here
139	// remove duplicate fields	162	// remove duplicate fields
140	if (count != fieldBindings.length)	163	if (count != fieldBindings.length)
141	System.arraycopy(fieldBindings, 0, fieldBindings = new FieldBinding[count], 0, count);	164	System.arraycopy(fieldBindings, 0, fieldBindings = new FieldBinding[count], 0, count);
		165	this.cumulativeFieldCount += count;
142	sourceType.tagBits &= ~(TagBits.AreFieldsSorted\|TagBits.AreFieldsComplete); // in case some static imports reached already into this type	166	sourceType.tagBits &= ~(TagBits.AreFieldsSorted\|TagBits.AreFieldsComplete); // in case some static imports reached already into this type
143	sourceType.setFields(fieldBindings);	167	sourceType.setFields(fieldBindings);
144	}	168	}
Lines 218-223 Link Here
218	checkParameterizedTypeBounds();	242	checkParameterizedTypeBounds();
219	checkParameterizedSuperTypeCollisions();	243	checkParameterizedSuperTypeCollisions();
220	}	244	}
		245	this.cumulativeFieldCount += outerMostMethodScope().analysisIndex;
		246	this.localTypeFieldIdStart = outerMostMethodScope().analysisIndex;
221	buildFieldsAndMethods();	247	buildFieldsAndMethods();
222	localType.faultInTypesForFieldsAndMethods();	248	localType.faultInTypesForFieldsAndMethods();
223		249
Lines 1251-1254 Link Here
1251	+ this.referenceContext.binding.toString();	1277	+ this.referenceContext.binding.toString();
1252	return "--- Class Scope ---\n\n Binding not initialized" ; //$NON-NLS-1$	1278	return "--- Class Scope ---\n\n Binding not initialized" ; //$NON-NLS-1$
1253	}	1279	}
		1280
		1281	private int findFieldCountFromSuperInterfaces(ReferenceBinding[] superinterfaces) {
		1282	int numOfFields = 0;
		1283	if (superinterfaces == null)
		1284	return numOfFields ;
		1285	for (int i = 0; i < superinterfaces.length; i++) {
		1286	numOfFields += superinterfaces[i].fieldCount();
		1287	numOfFields += findFieldCountFromSuperInterfaces(superinterfaces[i].superInterfaces());
		1288	}
		1289	return numOfFields;
		1290	}
1254	}	1291	}




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

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

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

	}
	return null;
}

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

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




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

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

	private SimpleLookupTable compatibleCache;


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

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




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

			return CompilerOptions.VarargsArgumentNeedCast;

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

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

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

		case IProblem.BoxingConversion :

	}
}

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

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

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

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

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

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

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

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

public void methodMustOverride(AbstractMethodDeclaration method, long complianceLevel) {




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

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

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


Lines 1-5 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetClassFile.java (-1 / +1 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 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 32-38 Link Here

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




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

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

	return copy;
}

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

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

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





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

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


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


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


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


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


			"}"},
		"null220");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Return to bug 247564

Lines 807-812 Link Here

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

Lines 103-108 Link Here

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

Lines 572-577 Link Here

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

Lines 1245-1250 Link Here

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

Lines 24-46 Link Here

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

Lines 31-46 Link Here

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

Lines 43-48 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java (-12 / +124 lines)
43	public MethodScope staticInitializerScope;	43	public MethodScope staticInitializerScope;
44	public boolean ignoreFurtherInvestigation = false;	44	public boolean ignoreFurtherInvestigation = false;
45	public int maxFieldCount;	45	public int maxFieldCount;
		46	// public int maxFieldCountForFlowInfo; // cumulative count of fields in this type and enclosing types
46	public int declarationSourceStart;	47	public int declarationSourceStart;
47	public int declarationSourceEnd;	48	public int declarationSourceEnd;
48	public int bodyStart;	49	public int bodyStart;
Lines 59-64 Link Here
59		60
60	// 1.5 support	61	// 1.5 support
61	public TypeParameter[] typeParameters;	62	public TypeParameter[] typeParameters;
		63	private int maxFieldCountForFlowInfo;
62		64
63	public TypeDeclaration(CompilationResult compilationResult){	65	public TypeDeclaration(CompilationResult compilationResult){
64	this.compilationResult = compilationResult;	66	this.compilationResult = compilationResult;
Lines 198-205 Link Here
198	localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));	200	localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));
199	}	201	}
200	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);	202	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
		203
		204
		205
		206	// if (this.enclosingType != null) {
		207	// this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
		208	// } else {
		209	// this.maxFieldCountForFlowInfo = this.maxFieldCount;
		210	// }
201	updateMaxFieldCount(); // propagate down the max field count	211	updateMaxFieldCount(); // propagate down the max field count
202	internalAnalyseCode(flowContext, flowInfo);	212
		213	// if ((this.binding.tagBits & ASTNode.IsLocalType) != 0) {
		214	// // non-anonymous local type can declare its fields. So change the cumulativeFieldCount
		215	// UnconditionalFlowInfo unconFlowInfo = flowInfo.unconditionalInits();
		216	// int tempCount = unconFlowInfo.maxFieldCount;
		217	// unconFlowInfo.maxFieldCount = this.scope.cumulativeFieldCount;
		218	// internalAnalyseCode(flowContext, flowInfo);
		219	// unconFlowInfo.maxFieldCount = tempCount;
		220	// } else {
		221
		222	internalAnalyseCode(flowContext, flowInfo);
		223	// }
203	} catch (AbortType e) {	224	} catch (AbortType e) {
204	this.ignoreFurtherInvestigation = true;	225	this.ignoreFurtherInvestigation = true;
205	}	226	}
Lines 214-219 Link Here
214	if (this.ignoreFurtherInvestigation)	235	if (this.ignoreFurtherInvestigation)
215	return;	236	return;
216	try {	237	try {
		238
		239
		240	// if (this.enclosingType == null) {
		241	// this.maxFieldCountForFlowInfo = this.maxFieldCount;
		242	// } else {
		243	// this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
		244	// }
217	// propagate down the max field count	245	// propagate down the max field count
218	updateMaxFieldCount();	246	updateMaxFieldCount();
219	internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCount));	247	internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCount));
Lines 236-243 Link Here
236	localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));	264	localType.setConstantPoolName(currentScope.compilationUnitScope().computeConstantPoolName(localType));
237	}	265	}
238	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);	266	manageEnclosingInstanceAccessIfNecessary(currentScope, flowInfo);
		267
		268
		269
		270	// if (this.enclosingType == null) {
		271	// this.maxFieldCountForFlowInfo = this.maxFieldCount;
		272	// } else {
		273	// this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
		274	// }
239	updateMaxFieldCount(); // propagate down the max field count	275	updateMaxFieldCount(); // propagate down the max field count
		276	//flowInfo.unconditionalInits().maxFieldCount = this.maxFieldCountForFlowInfo;
		277	UnconditionalFlowInfo unconFlowInfo = flowInfo.unconditionalInits();
		278	//int tempCount = unconFlowInfo.maxFieldCount;
		279	//unconFlowInfo.maxFieldCount = this.scope.cumulativeFieldCount;
240	internalAnalyseCode(flowContext, flowInfo);	280	internalAnalyseCode(flowContext, flowInfo);
		281	//flowInfo.resetNullInfoForFields();
		282	//unconFlowInfo.maxFieldCount = tempCount;
241	} catch (AbortType e) {	283	} catch (AbortType e) {
242	this.ignoreFurtherInvestigation = true;	284	this.ignoreFurtherInvestigation = true;
243	}	285	}
Lines 251-256 Link Here
251	if (this.ignoreFurtherInvestigation)	293	if (this.ignoreFurtherInvestigation)
252	return;	294	return;
253	try {	295	try {
		296	// if (this.enclosingType == null) {
		297	// this.maxFieldCountForFlowInfo = this.maxFieldCount;
		298	// } else {
		299	// this.maxFieldCountForFlowInfo = this.enclosingType.maxFieldCountForFlowInfo + this.maxFieldCount;
		300	// }
254	internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCount));	301	internalAnalyseCode(null, FlowInfo.initial(this.maxFieldCount));
255	} catch (AbortType e) {	302	} catch (AbortType e) {
256	this.ignoreFurtherInvestigation = true;	303	this.ignoreFurtherInvestigation = true;
Lines 646-652 Link Here
646	// branch, since the previous initializer already got the blame.	693	// branch, since the previous initializer already got the blame.
647	if (staticFieldInfo == FlowInfo.DEAD_END) {	694	if (staticFieldInfo == FlowInfo.DEAD_END) {
648	this.staticInitializerScope.problemReporter().initializerMustCompleteNormally(field);	695	this.staticInitializerScope.problemReporter().initializerMustCompleteNormally(field);
649	staticFieldInfo = FlowInfo.initial(this.maxFieldCount).setReachMode(FlowInfo.UNREACHABLE);	696	staticFieldInfo = FlowInfo.initial(this.scope.cumulativeFieldCount).setReachMode(FlowInfo.UNREACHABLE);
650	}	697	}
651	} else {	698	} else {
652	if ((nonStaticFieldInfo.tagBits & FlowInfo.UNREACHABLE) != 0)	699	if ((nonStaticFieldInfo.tagBits & FlowInfo.UNREACHABLE) != 0)
Lines 662-668 Link Here
662	// branch, since the previous initializer already got the blame.	709	// branch, since the previous initializer already got the blame.
663	if (nonStaticFieldInfo == FlowInfo.DEAD_END) {	710	if (nonStaticFieldInfo == FlowInfo.DEAD_END) {
664	this.initializerScope.problemReporter().initializerMustCompleteNormally(field);	711	this.initializerScope.problemReporter().initializerMustCompleteNormally(field);
665	nonStaticFieldInfo = FlowInfo.initial(this.maxFieldCount).setReachMode(FlowInfo.UNREACHABLE);	712	nonStaticFieldInfo = FlowInfo.initial(this.scope.cumulativeFieldCount).setReachMode(FlowInfo.UNREACHABLE);
666	}	713	}
667	}	714	}
668	}	715	}
Lines 678-684 Link Here
678	}	725	}
679	if (this.methods != null) {	726	if (this.methods != null) {
680	UnconditionalFlowInfo outerInfo = flowInfo.unconditionalFieldLessCopy();	727	UnconditionalFlowInfo outerInfo = flowInfo.unconditionalFieldLessCopy();
681	FlowInfo constructorInfo = nonStaticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo);	728	boolean isLocal = (this.binding.tagBits & ASTNode.IsLocalType) != 0;
		729	//int fieldOffset = isLocal ? this.scope.cumulativeFieldCount : this.maxFieldCount;
		730	//int fieldStart = isLocal ? this.scope.localTypeFieldIdStart : 0;
		731	FlowInfo constructorInfo = nonStaticFieldInfo.unconditionalInits().discardNonFieldInitializations(0).addInitializationsFrom(outerInfo);
682	for (int i = 0, count = this.methods.length; i < count; i++) {	732	for (int i = 0, count = this.methods.length; i < count; i++) {
683	AbstractMethodDeclaration method = this.methods[i];	733	AbstractMethodDeclaration method = this.methods[i];
684	if (method.ignoreFurtherInvestigation)	734	if (method.ignoreFurtherInvestigation)
Lines 688-694 Link Here
688	method.analyseCode(	738	method.analyseCode(
689	this.scope,	739	this.scope,
690	staticInitializerContext,	740	staticInitializerContext,
691	staticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo));	741	staticFieldInfo.unconditionalInits().discardNonFieldInitializations(0).addInitializationsFrom(outerInfo));
692	} else { // constructor	742	} else { // constructor
693	((ConstructorDeclaration)method).analyseCode(this.scope, initializerContext, constructorInfo.copy(), flowInfo.reachMode());	743	((ConstructorDeclaration)method).analyseCode(this.scope, initializerContext, constructorInfo.copy(), flowInfo.reachMode());
694	}	744	}
Lines 1042-1052 Link Here
1042	this.typeParameters[i].resolve(this.scope);	1092	this.typeParameters[i].resolve(this.scope);
1043	}	1093	}
1044	}	1094	}
1045	if (this.memberTypes != null) {	1095
1046	for (int i = 0, count = this.memberTypes.length; i < count; i++) {	1096	// field count from supertypes should be included in maxFieldCount,
1047	this.memberTypes[i].resolve(this.scope);	1097	// so that a field from supertype doesn't end up with same id as a local variable
1048	}	1098	// in a method being analyzed.
1049	}	1099	int superFieldsCount = 0;
		1100	ReferenceBinding superClassBinding = sourceType.superclass;
		1101	while (superClassBinding != null) {
		1102	FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
		1103	if (unResolvedFields != null) {
		1104	superFieldsCount += unResolvedFields.length;
		1105	}
		1106	superFieldsCount += findFieldCountFromSuperInterfaces(superClassBinding.superInterfaces());
		1107	superClassBinding = superClassBinding.superclass();
		1108	}
		1109	ReferenceBinding[] superInterfacesBinding = this.binding.superInterfaces;
		1110	superFieldsCount += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		1111	this.scope.cumulativeFieldCount += superFieldsCount;
1050	if (this.fields != null) {	1112	if (this.fields != null) {
1051	for (int i = 0, count = this.fields.length; i < count; i++) {	1113	for (int i = 0, count = this.fields.length; i < count; i++) {
1052	FieldDeclaration field = this.fields[i];	1114	FieldDeclaration field = this.fields[i];
Lines 1067-1072 Link Here
1067	this.ignoreFurtherInvestigation = true;	1129	this.ignoreFurtherInvestigation = true;
1068	continue;	1130	continue;
1069	}	1131	}
		1132	field.binding.id += superFieldsCount;
1070	if (needSerialVersion	1133	if (needSerialVersion
1071	&& ((fieldBinding.modifiers & (ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal)) == (ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal))	1134	&& ((fieldBinding.modifiers & (ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal)) == (ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal))
1072	&& CharOperation.equals(TypeConstants.SERIALVERSIONUID, fieldBinding.name)	1135	&& CharOperation.equals(TypeConstants.SERIALVERSIONUID, fieldBinding.name)
Lines 1084-1092 Link Here
1084	field.resolve(field.isStatic() ? this.staticInitializerScope : this.initializerScope);	1147	field.resolve(field.isStatic() ? this.staticInitializerScope : this.initializerScope);
1085	}	1148	}
1086	}	1149	}
1087	if (this.maxFieldCount < localMaxFieldCount) {	1150
1088	this.maxFieldCount = localMaxFieldCount;	1151	// if (this.maxFieldCount < localMaxFieldCount) {
		1152	// this.maxFieldCount = localMaxFieldCount;
		1153	// }
		1154	this.maxFieldCount = this.scope.cumulativeFieldCount;
		1155	if (this.memberTypes != null) {
		1156	for (int i = 0, count = this.memberTypes.length; i < count; i++) {
		1157	this.memberTypes[i].resolve(this.scope);
		1158	}
1089	}	1159	}
		1160	// if (this.memberTypes != null) {
		1161	// for (int i = 0, count = this.memberTypes.length; i < count; i++) {
		1162	// this.memberTypes[i].maxFieldCount += this.maxFieldCount;
		1163	// }
		1164	// }
		1165
		1166	// if (this.enclosingType != null)
		1167	// this.maxFieldCount += this.enclosingType.maxFieldCount;
		1168
1090	if (needSerialVersion) {	1169	if (needSerialVersion) {
1091	//check that the current type doesn't extend javax.rmi.CORBA.Stub	1170	//check that the current type doesn't extend javax.rmi.CORBA.Stub
1092	TypeBinding javaxRmiCorbaStub = this.scope.getType(TypeConstants.JAVAX_RMI_CORBA_STUB, 4);	1171	TypeBinding javaxRmiCorbaStub = this.scope.getType(TypeConstants.JAVAX_RMI_CORBA_STUB, 4);
Lines 1173-1178 Link Here
1173	}	1252	}
1174	}	1253	}
1175		1254
		1255	private int findFieldCountFromSuperInterfaces(ReferenceBinding[] superinterfaces) {
		1256	int numOfFields = 0;
		1257	if (superinterfaces == null)
		1258	return numOfFields ;
		1259	for (int i = 0; i < superinterfaces.length; i++) {
		1260	numOfFields += superinterfaces[i].fieldCount();
		1261	numOfFields += findFieldCountFromSuperInterfaces(superinterfaces[i].superInterfaces());
		1262	}
		1263	return numOfFields;
		1264	}
		1265
1176	/**	1266	/**
1177	* Resolve a local type declaration	1267	* Resolve a local type declaration
1178	*/	1268	*/
Lines 1449-1456 Link Here
1449	} else {	1539	} else {
1450	this.maxFieldCount = outerMostType.maxFieldCount; // down	1540	this.maxFieldCount = outerMostType.maxFieldCount; // down
1451	}	1541	}
		1542
1452	}	1543	}
1453		1544
		1545	//int getMaxFieldCountForFlowInfo() {
		1546	// int maxFieldCountForFlowInfo = 0;
		1547	// if (this.binding == null)
		1548	// return maxFieldCountForFlowInfo; // error scenario
		1549	// ReferenceBinding superClassBinding = this.binding.superclass;
		1550	// while (superClassBinding != null) {
		1551	// FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
		1552	// if (unResolvedFields != null) {
		1553	// this.maxFieldCount += unResolvedFields.length;
		1554	// }
		1555	// superClassBinding = superClassBinding.superclass();
		1556	// }
		1557	// ReferenceBinding[] superInterfacesBinding = this.binding.superInterfaces;
		1558	// maxFieldCountForFlowInfo += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		1559	// if (this.enclosingType != null) {
		1560	// maxFieldCountForFlowInfo += this.enclosingType.maxFieldCount;
		1561	// }
		1562	// return maxFieldCountForFlowInfo;
		1563	//
		1564	//}
		1565
1454	/**	1566	/**
1455	* Returns whether the type is a secondary one or not.	1567	* Returns whether the type is a secondary one or not.
1456	*/	1568	*/

Lines 11-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/flow/NullInfoRegistry.java (-15 / +51 lines)
11	*******************************************************************************/	11	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.flow;	12	package org.eclipse.jdt.internal.compiler.flow;
13		13
14	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;	14	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
		15	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
15		16
16	/**	17	/**
17	* A degenerate form of UnconditionalFlowInfo explicitly meant to capture	18	* A degenerate form of UnconditionalFlowInfo explicitly meant to capture
Lines 116-128 Link Here
116	return this;	117	return this;
117	}	118	}
118		119
119	public void markAsComparedEqualToNonNull(LocalVariableBinding local) {	120	public void markAsComparedEqualToNonNull(VariableBinding local) {
120	// protected from non-object locals in calling methods	121	// protected from non-object locals in calling methods
121	if (this != DEAD_END) {	122	if (this != DEAD_END) {
122	this.tagBits \|= NULL_FLAG_MASK;	123	this.tagBits \|= NULL_FLAG_MASK;
123	int position;	124	int position;
		125	if (local instanceof FieldBinding) {
		126	position = local.id;
		127	} else {
		128	position = local.id + this.maxFieldCount;
		129	}
124	// position is zero-based	130	// position is zero-based
125	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	131	if (position < BitCacheSize) { // use bits
126	// set protected non null	132	// set protected non null
127	this.nullBit1 \|= (1L << position);	133	this.nullBit1 \|= (1L << position);
128	if (COVERAGE_TEST_FLAG) {	134	if (COVERAGE_TEST_FLAG) {
Lines 161-173 Link Here
161	}	167	}
162	}	168	}
163		169
164	public void markAsDefinitelyNonNull(LocalVariableBinding local) {	170	public void markAsDefinitelyNonNull(VariableBinding local) {
165	// protected from non-object locals in calling methods	171	// protected from non-object locals in calling methods
166	if (this != DEAD_END) {	172	if (this != DEAD_END) {
167	this.tagBits \|= NULL_FLAG_MASK;	173	this.tagBits \|= NULL_FLAG_MASK;
168	int position;	174	int position;
169	// position is zero-based	175	// position is zero-based
170	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	176	if (local instanceof FieldBinding) {
		177	position = local.id;
		178	} else {
		179	position = local.id + this.maxFieldCount;
		180	}
		181	if (position < BitCacheSize) { // use bits
171	// set assigned non null	182	// set assigned non null
172	this.nullBit3 \|= (1L << position);	183	this.nullBit3 \|= (1L << position);
173	if (COVERAGE_TEST_FLAG) {	184	if (COVERAGE_TEST_FLAG) {
Lines 207-219 Link Here
207	}	218	}
208	// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either	219	// PREMATURE consider ignoring extra 0 to 2 included - means a1 should not be used either
209	// PREMATURE project protected non null onto something else	220	// PREMATURE project protected non null onto something else
210	public void markAsDefinitelyNull(LocalVariableBinding local) {	221	public void markAsDefinitelyNull(VariableBinding local) {
211	// protected from non-object locals in calling methods	222	// protected from non-object locals in calling methods
212	if (this != DEAD_END) {	223	if (this != DEAD_END) {
213	this.tagBits \|= NULL_FLAG_MASK;	224	this.tagBits \|= NULL_FLAG_MASK;
214	int position;	225	int position;
		226	if (local instanceof FieldBinding) {
		227	position = local.id;
		228	} else {
		229	position = local.id + this.maxFieldCount;
		230	}
215	// position is zero-based	231	// position is zero-based
216	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	232	if (position < BitCacheSize) { // use bits
217	// set assigned null	233	// set assigned null
218	this.nullBit2 \|= (1L << position);	234	this.nullBit2 \|= (1L << position);
219	if (COVERAGE_TEST_FLAG) {	235	if (COVERAGE_TEST_FLAG) {
Lines 252-264 Link Here
252	}	268	}
253	}	269	}
254		270
255	public void markAsDefinitelyUnknown(LocalVariableBinding local) {	271	public void markAsDefinitelyUnknown(VariableBinding local) {
256	// protected from non-object locals in calling methods	272	// protected from non-object locals in calling methods
257	if (this != DEAD_END) {	273	if (this != DEAD_END) {
258	this.tagBits \|= NULL_FLAG_MASK;	274	this.tagBits \|= NULL_FLAG_MASK;
259	int position;	275	int position;
		276	if (local instanceof FieldBinding) {
		277	position = local.id;
		278	} else {
		279	position = local.id + this.maxFieldCount;
		280	}
260	// position is zero-based	281	// position is zero-based
261	if ((position = local.id + this.maxFieldCount) < BitCacheSize) { // use bits	282	if (position < BitCacheSize) { // use bits
262	// set assigned unknown	283	// set assigned unknown
263	this.nullBit4 \|= (1L << position);	284	this.nullBit4 \|= (1L << position);
264	if (COVERAGE_TEST_FLAG) {	285	if (COVERAGE_TEST_FLAG) {
Lines 407-419 Link Here
407	* Mark a local as potentially having been assigned to an unknown value.	428	* Mark a local as potentially having been assigned to an unknown value.
408	* @param local the local to mark	429	* @param local the local to mark
409	*/	430	*/
410	public void markPotentiallyUnknownBit(LocalVariableBinding local) {	431	public void markPotentiallyUnknownBit(VariableBinding local) {
411	// protected from non-object locals in calling methods	432	// protected from non-object locals in calling methods
412	if (this != DEAD_END) {	433	if (this != DEAD_END) {
413	this.tagBits \|= NULL_FLAG_MASK;	434	this.tagBits \|= NULL_FLAG_MASK;
414	int position;	435	int position;
415	long mask;	436	long mask;
416	if ((position = local.id + this.maxFieldCount) < BitCacheSize) {	437	if (local instanceof FieldBinding) {
		438	position = local.id;
		439	} else {
		440	position = local.id + this.maxFieldCount;
		441	}
		442	if (position < BitCacheSize) {
417	// use bits	443	// use bits
418	mask = 1L << position;	444	mask = 1L << position;
419	isTrue((this.nullBit1 & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$	445	isTrue((this.nullBit1 & mask) == 0, "Adding 'unknown' mark in unexpected state"); //$NON-NLS-1$
Lines 454-465 Link Here
454	}	480	}
455	}	481	}
456		482
457	public void markPotentiallyNullBit(LocalVariableBinding local) {	483	public void markPotentiallyNullBit(VariableBinding local) {
458	if (this != DEAD_END) {	484	if (this != DEAD_END) {
459	this.tagBits \|= NULL_FLAG_MASK;	485	this.tagBits \|= NULL_FLAG_MASK;
460	int position;	486	int position;
461	long mask;	487	long mask;
462	if ((position = local.id + this.maxFieldCount) < BitCacheSize) {	488	if (local instanceof FieldBinding) {
		489	position = local.id;
		490	} else {
		491	position = local.id + this.maxFieldCount;
		492	}
		493	if (position < BitCacheSize) {
463	// use bits	494	// use bits
464	mask = 1L << position;	495	mask = 1L << position;
465	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$	496	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially null' mark in unexpected state"); //$NON-NLS-1$
Lines 500-511 Link Here
500	}	531	}
501	}	532	}
502		533
503	public void markPotentiallyNonNullBit(LocalVariableBinding local) {	534	public void markPotentiallyNonNullBit(VariableBinding local) {
504	if (this != DEAD_END) {	535	if (this != DEAD_END) {
505	this.tagBits \|= NULL_FLAG_MASK;	536	this.tagBits \|= NULL_FLAG_MASK;
506	int position;	537	int position;
507	long mask;	538	long mask;
508	if ((position = local.id + this.maxFieldCount) < BitCacheSize) {	539	if (local instanceof FieldBinding) {
		540	position = local.id;
		541	} else {
		542	position = local.id + this.maxFieldCount;
		543	}
		544	if (position < BitCacheSize) {
509	// use bits	545	// use bits
510	mask = 1L << position;	546	mask = 1L << position;
511	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$	547	isTrue((this.nullBit1 & mask) == 0, "Adding 'potentially non-null' mark in unexpected state"); //$NON-NLS-1$

Lines 696-701 Link Here

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