Attachment #209774 for bug #247564

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




			"public class X {\n" +
			"  Object o;\n" +
			"  void foo() {\n" +
			"      o = null;\n" +
			"  }\n" +
			"  void foo1() {\n" + 
			"	 o.toString();\n" +

			"            if (field == null) { \n" +
			"                field = new Object();\n" +
			"            }\n" +
			"            field.toString(); // Wrong outcome was: Pot. NPE\n" +
			"            i--;\n" +
			"        }\n" +
			"    }\n" +

			"  }\n" +
			"  void foo1() {\n" +
			"    if (o == null) {\n" +
			"        o.toString(); // danger\n" +
			"        return;\n" +
			"    }\n" +
			"	 o.toString(); // safe\n" +

			"}\n"},
			"----------\n" + 
			"1. ERROR in X.java (at line 13)\n" + 
			"	o.toString(); // danger\n" + 
			"	^\n" + 
			"Null pointer access: The field o can only be null at this location\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 22)\n" + 
			"	o.toString(); // uncertain\n" + 
			"	^\n" + 
			"Potential null pointer access: The field o may be null at this location\n" + 

			"  }\n" +
			"  void foo1() {\n" +
			"    if (o == null) {\n" +
			"        o.toString(); // danger\n" +
			"        return;\n" +
			"    }\n" +
			"	 o.toString(); // safe\n" +

			"}\n"},
			"----------\n" + 
			"1. ERROR in X.java (at line 39)\n" + 
			"	o.toString(); // danger\n" + 
			"	^\n" + 
			"Null pointer access: The field o can only be null at this location\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 48)\n" + 
			"	o.toString(); // uncertain\n" + 
			"	^\n" + 
			"Potential null pointer access: The field o may be null at this location\n" + 

			"	 if (o == null) {\n" +	// don't know o's nullness, so silent
			"		o.toString();\n" + // report NPE
			"	 }\n" +
			"    local.toString();\n" + // try to diffuse status for o / o2
			"	 o.toString();\n" +	// already reported NPE above. So silent. Same behaviour as 'local'
			"	 if (o2 == null) {\n" + // report always false null check
			"		o2.toString();\n" + // dead code

			"	^\n" + 
			"Null pointer access: The field o can only be null at this location\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 23)\n" + 
			"	if (o2 == null) {\n" + 
			"	    ^^\n" + 
			"Null comparison always yields false: The field o2 cannot be null at this location\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 23)\n" + 
			"	if (o2 == null) {\n" + 
			"		o2.toString();\n" + 
			"	 }\n" + 

	);
}

// null analysis -- case for static final field initialized inside static block with different values
// check if the resetting works properly i.e. null status for constant fields should not be 
// reset on method calls. This test is for constructors
public void testBug247564b_6() {
	this.runNegativeTest(
		new String[] {

			"	 if (o == null) {\n" +	// don't know o's nullness, so silent
			"		o.toString();\n" + // report NPE
			"	 }\n" +
			"    local.toString();\n" + // try to diffuse status for o / o2
			"	 o.toString();\n" +	// already reported NPE above. So silent. Same behaviour as 'local'
			"	 if (o2 == null) {\n" + // report always false null check
			"		o2.toString();\n" + // dead code

			"	^\n" + 
			"Null pointer access: The field o can only be null at this location\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 23)\n" + 
			"	if (o2 == null) {\n" + 
			"	    ^^\n" + 
			"Null comparison always yields false: The field o2 cannot be null at this location\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 23)\n" + 
			"	if (o2 == null) {\n" + 
			"		o2.toString();\n" + 
			"	 }\n" + 

	);
}

// null analysis -- case for static final field initialized inside static block with different values
// check if the resetting works properly i.e. null status for constant fields should not be 
// reset on method calls. This test is for constructors
public void testBug247564b_6_2() {
	this.runNegativeTest(
		new String[] {

			"	 if (o == null) {\n" +	// don't know o's nullness, so silent
			"		o.toString();\n" + // report NPE
			"	 }\n" +
			"    local.toString();\n" + // try to diffuse status for o / o2
			"	 o.toString();\n" +	// already reported NPE above. So silent. Same behaviour as 'local'
			"	 if (o2 == null) {\n" + // report always false null check
			"		o2.toString();\n" + // dead code

			"	^\n" + 
			"Null pointer access: The field o can only be null at this location\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 49)\n" + 
			"	if (o2 == null) {\n" + 
			"	    ^^\n" + 
			"Null comparison always yields false: The field o2 cannot be null at this location\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 49)\n" + 
			"	if (o2 == null) {\n" + 
			"		o2.toString();\n" + 
			"	 }\n" + 

			"	 if (o1 == null) {\n" +	// can't be null, was dereferenced in static initializer
			"		o1.toString();\n" + // dead
			"	 }\n" +
			"    local.toString();\n" + // try to diffuse status for o1 / o2
			"	 o1.toString();\n" +	// safe
			"	 if (o2 == null) {\n" + // report always false null check
			"		o2.toString();\n" + // dead code

			"	                ^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Dead code\n" + 
			"----------\n" + 
			"6. ERROR in X.java (at line 23)\n" + 
			"	if (o2 == null) {\n" + 
			"	    ^^\n" + 
			"Null comparison always yields false: The field o2 cannot be null at this location\n" + 
			"----------\n" + 
			"7. WARNING in X.java (at line 23)\n" + 
			"	if (o2 == null) {\n" + 
			"		o2.toString();\n" + 
			"	 }\n" + 

			"	 if (o1 == null) {\n" +	// report redundant null check
			"		o1.toString();\n" + // report NPE
			"	 }\n" +
			"    local.toString();\n" + // try to diffuse status for o1 / o2
			"	 o1.toString();\n" +	// already reported NPE above. So silent. Same behaviour as 'local'
			"	 if (o2 == null) {\n" + // report always false null check
			"		o2.toString();\n" + // dead code

		"	^^\n" + 
		"Null pointer access: The field o1 can only be null at this location\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 41)\n" + 
		"	if (o2 == null) {\n" + 
		"	    ^^\n" + 
		"Null comparison always yields false: The field o2 cannot be null at this location\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 41)\n" + 
		"	if (o2 == null) {\n" + 
		"		o2.toString();\n" + 
		"	 }\n" + 

			"	 if (o1 == null) {\n" +	// report redundant null check
			"		o1.toString();\n" + // report NPE
			"	 }\n" +
			"    local.toString();\n" + // try to diffuse status for o1 / o2
			"	 o1.toString();\n" +	// already reported NPE above. So silent. Same behaviour as 'local'
			"	 if (o2 == null) {\n" + // report always false null check
			"		o2.toString();\n" + // dead code

		"	^^\n" + 
		"Null pointer access: The field o1 can only be null at this location\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 19)\n" + 
		"	if (o2 == null) {\n" + 
		"	    ^^\n" + 
		"Null comparison always yields false: The field o2 cannot be null at this location\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 19)\n" + 
		"	if (o2 == null) {\n" + 
		"		o2.toString();\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();

			"      if (this.field99 == null && this.field99.hashCode() == 0){}\n" +
			"	   this.field98 = null;\n" +
			"	}\n" +
			"	if (this.field98.hashCode() == 0) {}\n" +
			"	this.field97 = null;\n" +
			"	if (this.field97.hashCode() == 0) {}\n" +
			"	if (this.field100.hashCode() == 0) {}\n" +

}

// null analysis -- simple case for field for inner class
// to make sure that id's of local variables in inner classes don't conflict with those of fields.
public void testBug247564h_1() {
	this.runNegativeTest(
		new String[] {

}

// null analysis -- simple case for field for inner class
// to make sure that id's of local variables in inner classes don't conflict with those of fields.
public void testBug247564h_2() {
	this.runNegativeTest(
		new String[] {

			"	 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 field22;\n" +
			"  Object field22;\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 

			"    	if (X.field0 == null && X.field0.toString() == \"\"){}\n" +   // warn
			"    	if (this.field0 == null && X.field0.toString() == \"\"){}\n" +   // warn
			"    	if (X.field0 == null && this.field0.toString() == \"\"){}\n" +   // warn
			"    	if (X.field0 == null && getX().field0.toString() == \"\"){}\n" +   // no warn (diffused by getX() call)
			"  }\n" +
			"}\n" +
			"class Y{\n" +

			"  static Y getY(){ return new Y();}\n" +
			"  static X getX() { return new X();}\n" +
			"  static class XInner{\n" +
			"    static Object xinnerfield;\n" +
			"    XInner getXInner() { return new XInner();\n}" +
			"    void goo(Object var) {\n" +
			"    	if (new Y().getY().yField1 == null && field0.toString() == \"\"){}\n" +  // no warn
			"    	if (getY().yField1 == null && field0.toString() == \"\"){}\n" +  // no warn
			"    	if (new Y().getX().field0 == null && field0.toString() == \"\"){}\n" +   // warn

			"    	if (Y.xiny.field1 == null && Y.yField1.toString() == \"\"){}\n" +  // no warn
			"    	if (X.field0 == null && X.field0.toString() == \"\"){}\n" +   // warn
			"    	if (X.field0 == null && getX().field0.toString() == \"\"){}\n" +   // no warn
			"    }\n" +
			"  }\n" +
			"}\n" +
			"class Y{\n" +

	this.runNegativeTest(
		new String[] {
			"X.java",
			"class MyException extends Exception{}\n" +
			"public class X {\n" +
			"  private Object f;\n" +
			"	 void gooCalls() throws MyException{}\n" +

			"}\n"},
		"----------\n" + 
		"1. WARNING in X.java (at line 1)\n" + 
		"	class MyException extends Exception{}\n" + 
		"	      ^^^^^^^^^^^\n" + 
		"The serializable class MyException does not declare a static final serialVersionUID field of type long\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 12)\n" + 
		"	f.toString();\n" + 
		"	^\n" + 
		"Potential null pointer access: The field f may be null at this location\n" + 




			// TODO: handle all kinds of expressions (cf. also https://bugs.eclipse.org/364326)
		}

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




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

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

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





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

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

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

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

public boolean isPotentiallyAssigned(VariableBinding var) {

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

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

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

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

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

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

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

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

public void markAsDefinitelyAssigned(VariableBinding var) {

	this.initsWhenFalse.markAsDefinitelyAssigned(var);
}

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

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

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

public void resetNullInfoForFields() {

	this.initsWhenFalse.addConstantFieldsMask(other);
}

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

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

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

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

public FlowInfo setReachMode(int reachMode) {

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

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

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

public void resetAssignmentInfo(LocalVariableBinding var) {
	this.initsWhenTrue.resetAssignmentInfo(var);
	this.initsWhenFalse.resetAssignmentInfo(var);
}
}




		for (int i = 0; i < this.nullCount; i++) {
			Expression expression = this.nullReferences[i];
			// final local variable
			VariableBinding var = 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(var)) {
						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(var, expression);
							}
						} else {
							if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
								scope.problemReporter().variableNonNullComparedToNull(var, expression);
							}
						}
						continue;

				case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
				case CAN_ONLY_NULL | IN_ASSIGNMENT:
				case CAN_ONLY_NULL | IN_INSTANCEOF:
					if (flowInfo.isDefinitelyNull(var)) {
						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(var, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableRedundantCheckOnNull(var, 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(var, expression);
									continue;
								}
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNullComparedToNonNull(var, expression);
								}
								continue;
							case FlowContext.IN_ASSIGNMENT:
								scope.problemReporter().variableRedundantNullAssignment(var, expression);
								continue;
							case FlowContext.IN_INSTANCEOF:
								scope.problemReporter().variableNullInstanceof(var, expression);
								continue;
						}
					} else if (flowInfo.isPotentiallyNull(var)) {
						switch(this.nullCheckTypes[i] & CONTEXT_MASK) {
							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(var, 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(var, expression);
									continue;
								}
								break;

					}
					break;
				case MAY_NULL:
					if (flowInfo.isDefinitelyNull(var)) {
						scope.problemReporter().variableNullReference(var, expression);
						continue;
					}
					if (flowInfo.isPotentiallyNull(var)) {
						scope.problemReporter().variablePotentialNullReference(var, expression);
					}
					break;
				case ASSIGN_TO_NONNULL:
					int nullStatus = flowInfo.nullStatus(var);
					if (nullStatus != FlowInfo.NON_NULL) {
						char[][] annotationName = scope.environment().getNonNullAnnotationName();
						scope.problemReporter().nullityMismatch(expression, this.expectedTypes[i], nullStatus, annotationName);

		return true;
	}

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

					case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
					case CAN_ONLY_NULL | IN_ASSIGNMENT:
					case CAN_ONLY_NULL | IN_INSTANCEOF:
						if (flowInfo.cannotBeNull(var)) {
							if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NON_NULL)) {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableRedundantCheckOnNonNull(var, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
									flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
								}
							} else if (checkType == (CAN_ONLY_NULL_NON_NULL | IN_COMPARISON_NULL)) {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNonNullComparedToNull(var, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
									flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
								}
							}
							return;
						}
						if (flowInfo.canOnlyBeNull(var)) {
							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(var, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().variableRedundantCheckOnNull(var, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
										flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
									}
									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(var, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().variableNullComparedToNonNull(var, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
										flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
									}
									return;
								case FlowContext.IN_ASSIGNMENT:
									scope.problemReporter().variableRedundantNullAssignment(var, reference);
									return;
								case FlowContext.IN_INSTANCEOF:
									scope.problemReporter().variableNullInstanceof(var, reference);
									return;
							}
						} else if (flowInfo.isPotentiallyNull(var)) {
							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(var, 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(var, reference);
										return;
									}
									break;

						}
						break;
					case MAY_NULL :
						if (flowInfo.cannotBeNull(var)) {
							return;
						}
						if (flowInfo.canOnlyBeNull(var)) {
							scope.problemReporter().variableNullReference(var, reference);
							return;
						}
						break;

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

					case CAN_ONLY_NULL | IN_COMPARISON_NON_NULL:
					case CAN_ONLY_NULL | IN_ASSIGNMENT:
					case CAN_ONLY_NULL | IN_INSTANCEOF:
						if (flowInfo.isDefinitelyNull(var)) {
							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(var, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().variableRedundantCheckOnNull(var, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
										flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
									}
									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(var, reference);
										return;
									}
									if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
										scope.problemReporter().variableNullComparedToNonNull(var, reference);
									}
									if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(var)) {
										flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
									}
									return;
								case FlowContext.IN_ASSIGNMENT:
									scope.problemReporter().variableRedundantNullAssignment(var, reference);
									return;
								case FlowContext.IN_INSTANCEOF:
									scope.problemReporter().variableNullInstanceof(var, reference);
									return;
							}
						} else if (flowInfo.isPotentiallyNull(var)) {
							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(var, 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(var, reference);
										return;
									}
									break;

						}
						break;
					case MAY_NULL :
						if (flowInfo.isDefinitelyNull(var)) {
							scope.problemReporter().variableNullReference(var, reference);
							return;
						}
						if (flowInfo.isPotentiallyNull(var)) {
							scope.problemReporter().variablePotentialNullReference(var, reference);
							return;
						}
						if (flowInfo.isDefinitelyNonNull(var)) {
							return; // shortcut: cannot be null
						}
						break;

			if(((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) || checkType == MAY_NULL
					|| (checkType & CONTEXT_MASK) == FlowContext.IN_ASSIGNMENT
					|| (checkType & CONTEXT_MASK) == FlowContext.IN_INSTANCEOF) {
				recordNullReference(var, reference, checkType);
			}
			// prepare to re-check with try/catch flow info
		}

		}
	}

protected void recordNullReference(VariableBinding var,
	Expression expression, int status) {
	if (this.nullCount == 0) {
		this.nullVariables = new VariableBinding[5];

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

Lines 277-283 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowInfo.java (-1 / +1 lines)
277	/**	277	/**
278	* variant of {@link #resetNullInfo(VariableBinding)} for resetting null info for all fields	278	* variant of {@link #resetNullInfo(VariableBinding)} for resetting null info for all fields
279	* Note that each fields status after the reset will become def. unknown i.e. 1001	279	* Note that each fields status after the reset will become def. unknown i.e. 1001
280	* Also this method does not reset constant fields, which are identified by {@link #constantFieldsMask}	280	* Also this method does not reset constant fields
281	*/	281	*/
282	abstract public void resetNullInfoForFields();	282	abstract public void resetNullInfoForFields();
283		283




	return this;
}

final public boolean cannotBeDefinitelyNullOrNonNull(VariableBinding var) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(var.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = var.getAnalysisId(this.maxFieldCount);
	if (position < BitCacheSize) {
		// use bits
		return (

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

final public boolean cannotBeNull(VariableBinding var) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(var.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = var.getAnalysisId(this.maxFieldCount);
	if (position < BitCacheSize) {
		// use bits
		return (this.nullBit1 & this.nullBit3

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

final public boolean canOnlyBeNull(VariableBinding var) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(var.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = var.getAnalysisId(this.maxFieldCount);
	if (position < BitCacheSize) {
		// use bits
		return (this.nullBit1 & this.nullBit2

	return isDefinitelyAssigned(field.getAnalysisId(this.maxFieldCount));
}

final public boolean isDefinitelyAssigned(LocalVariableBinding var) {
	// do not want to complain in unreachable code if local declared in reachable code
	if ((this.tagBits & UNREACHABLE_OR_DEAD) != 0 && (var.declaration.bits & ASTNode.IsLocalDeclarationReachable) != 0) {
		return true;
	}
	return isDefinitelyAssigned(var.id + this.maxFieldCount);
}

final public boolean isDefinitelyAssigned(VariableBinding var) {

	}
}

final public boolean isDefinitelyNonNull(VariableBinding var) {
	boolean isField = var instanceof FieldBinding;
	if (isField && (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

			(this.tagBits & NULL_FLAG_MASK) == 0) {
		return false;
	}
	if ((var.type.tagBits & TagBits.IsBaseType) != 0 ||
			var.constant() != Constant.NotAConstant) { // String instances
		return true;
	}
	int position = var.getAnalysisId(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 var) {
	boolean isField = var instanceof FieldBinding;
	if (isField && (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

	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 ||
			(this.tagBits & NULL_FLAG_MASK) == 0 ||
			(var.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = var.getAnalysisId(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 var) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 ||
			(this.tagBits & NULL_FLAG_MASK) == 0) {
		return false;
	}
	int position = var.getAnalysisId(this.maxFieldCount);
	if (position < BitCacheSize) { // use bits
		return ((this.nullBit1 & this.nullBit4
				& ~this.nullBit2 & ~this.nullBit3) & (1L << position)) != 0;

}

// TODO (Ayush) Check why this method does not return true for protected non null (1111)
final public boolean isPotentiallyNonNull(VariableBinding var) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(var.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = var.getAnalysisId(this.maxFieldCount);
	if (position < BitCacheSize) { // use bits
		// use bits
		return ((this.nullBit3 & (~this.nullBit1 | ~this.nullBit2))

}

// TODO (Ayush) Check why this method does not return true for protected null
final public boolean isPotentiallyNull(VariableBinding var) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(var.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = var.getAnalysisId(this.maxFieldCount);
	if (position < BitCacheSize) {
		// use bits
		return ((this.nullBit2 & (~this.nullBit1 | ~this.nullBit3))

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

final public boolean isPotentiallyUnknown(VariableBinding var) {
	// do not want to complain in unreachable code
	if ((this.tagBits & UNREACHABLE) != 0 ||
			(this.tagBits & NULL_FLAG_MASK) == 0) {
		return false;
	}
	int position = var.getAnalysisId(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 var) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(var.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = var.getAnalysisId(this.maxFieldCount);
	if (position < BitCacheSize) { // use bits
		return (this.nullBit1 & this.nullBit3 & this.nullBit4 & (1L << position)) != 0;
	}

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

final public boolean isProtectedNull(VariableBinding var) {
	if ((this.tagBits & NULL_FLAG_MASK) == 0 ||
			(var.type.tagBits & TagBits.IsBaseType) != 0) {
		return false;
	}
	int position = var.getAnalysisId(this.maxFieldCount);
	if (position < BitCacheSize) {
		// use bits
		return (this.nullBit1 & this.nullBit2

		throw new AssertionFailedException("assertion failed: " + message); //$NON-NLS-1$
	return expression;
}
public void markAsComparedEqualToNonNull(VariableBinding var) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		int position;
		if (var instanceof FieldBinding) {
			if ((var.modifiers & AccConstant) == AccConstant) {
				position = var.getAnalysisId(this.maxFieldCount);
			} else {
				// non-final fields may be modified in separate threads and we cannot be sure about their
				// definite nullness. Hence, marking as definitely unknown to avoid deferring null check for these fields
				this.markAsDefinitelyUnknown(var);
				return;
			}
		} else {
			position = var.id + this.maxFieldCount;
		}
		long mask;
		long a1, a2, a3, a4, na2;

	}
}

public void markAsComparedEqualToNull(VariableBinding var) {
	// 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 (var instanceof FieldBinding) {
			if ((var.modifiers & AccConstant) == AccConstant) {
				position = var.getAnalysisId(this.maxFieldCount);
			} else {
				// non-final fields may be modified in separate threads and we cannot be sure about their
				// definite nullness. Hence, marking as potential null.
				this.markNullStatus(var, FlowInfo.POTENTIALLY_NULL);
				return;
			}
		} else {
			position = var.id + this.maxFieldCount;
		}
		if (position < BitCacheSize) {
			// use bits

		markAsDefinitelyAssigned(var.getAnalysisId(this.maxFieldCount));
}

public void markAsDefinitelyNonNull(VariableBinding var) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	long mask;
    	int position;
    	// position is zero-based
    	if (var instanceof FieldBinding) {
			if ((var.modifiers & AccConstant) == AccConstant) {
				position = var.getAnalysisId(this.maxFieldCount);
			} else {
	    		// non-final fields may be modified in separate threads and we cannot be sure about their
	    		// definite nullness. Hence, marking as definitely unknown to avoid deferring null check for these fields.
	    		this.markAsDefinitelyUnknown(var);
	    		return;
			}
    	} else {
    		position = var.id + this.maxFieldCount;
    	}
    	if (position < BitCacheSize) { // use bits
    		// set assigned non null

	}
}

public void markAsDefinitelyNull(VariableBinding var) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
    	this.tagBits |= NULL_FLAG_MASK;
    	long mask;
    	int position;
    	// position is zero-based
    	if (var instanceof FieldBinding) {
			if ((var.modifiers & AccConstant) == AccConstant) {
				position = var.getAnalysisId(this.maxFieldCount);
			} else {
	    		// non-final fields may be modified in separate threads and we cannot be sure about their
	    		// definite nullness. Hence, marking as potential null.
	    		this.markNullStatus(var, FlowInfo.POTENTIALLY_NULL);
	    		return;
			}
    	} else {
    		position = var.id + this.maxFieldCount;
    	}
    	if (position < BitCacheSize) { // use bits
    		// mark assigned null


/**
 * Mark a local as having been assigned to an unknown value.
 * @param var the local to mark
 */
// PREMATURE may try to get closer to markAsDefinitelyAssigned, but not
//			 obvious
public void markAsDefinitelyUnknown(VariableBinding var) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
		long mask;
		int position = var.getAnalysisId(this.maxFieldCount);
		if (position < BitCacheSize) {
			// use bits
			// mark assigned null

	}
}

public void resetNullInfo(VariableBinding var) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        long mask;
    	int position = var.getAnalysisId(this.maxFieldCount);
        if (position < BitCacheSize) {
            // use bits
            this.nullBit1 &= (mask = ~(1L << position));


/**
 * Mark a local as potentially having been assigned to an unknown value.
 * @param var the local to mark
 */
public void markPotentiallyUnknownBit(VariableBinding var) {
	// protected from non-object locals in calling methods
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        long mask;
    	int position = var.getAnalysisId(this.maxFieldCount);
        if (position < BitCacheSize) {
            // use bits
        	mask = 1L << position;

	}
}

public void markPotentiallyNullBit(VariableBinding var) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        long mask;
    	int position = var.getAnalysisId(this.maxFieldCount);
        if (position < BitCacheSize) {
            // use bits
        	mask = 1L << position;

	}
}

public void markPotentiallyNonNullBit(VariableBinding var) {
	if (this != DEAD_END) {
		this.tagBits |= NULL_FLAG_MASK;
        long mask;
    	int position = var.getAnalysisId(this.maxFieldCount);
        if (position < BitCacheSize) {
            // use bits
        	mask = 1L << position;

Return to bug 247564

Lines 526-547 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Expression.java (-11 / +11 lines)
526	* @param flowInfo the upstream flow info; caveat: may get modified	526	* @param flowInfo the upstream flow info; caveat: may get modified
527	*/	527	*/
528	public void checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo) {	528	public void checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo) {
529	VariableBinding local = variableBinding(scope);	529	VariableBinding var = variableBinding(scope);
530	if (local != null &&	530	if (var != null &&
531	(local.type.tagBits & TagBits.IsBaseType) == 0) {	531	(var.type.tagBits & TagBits.IsBaseType) == 0) {
532	if ((this.bits & ASTNode.IsNonNull) == 0) {	532	if ((this.bits & ASTNode.IsNonNull) == 0) {
533	flowContext.recordUsingNullReference(scope, local, this,	533	flowContext.recordUsingNullReference(scope, var, this,
534	FlowContext.MAY_NULL, flowInfo);	534	FlowContext.MAY_NULL, flowInfo);
535	}	535	}
536	flowInfo.markAsComparedEqualToNonNull(local );	536	flowInfo.markAsComparedEqualToNonNull(var );
537	// from thereon it is set	537	// from thereon it is set
538	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	538	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
539	flowInfo.markedAsNullOrNonNullInAssertExpression(local);	539	flowInfo.markedAsNullOrNonNullInAssertExpression(var);
540	}	540	}
541	if (flowContext.initsOnFinally != null) {	541	if (flowContext.initsOnFinally != null) {
542	flowContext.initsOnFinally.markAsComparedEqualToNonNull(local);	542	flowContext.initsOnFinally.markAsComparedEqualToNonNull(var);
543	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	543	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
544	flowContext.initsOnFinally.markedAsNullOrNonNullInAssertExpression(local);	544	flowContext.initsOnFinally.markedAsNullOrNonNullInAssertExpression(var);
545	}	545	}
546	}	546	}
547	}	547	}
Lines 873-881 Link Here
873	this.constant != null && this.constant != Constant.NotAConstant)	873	this.constant != null && this.constant != Constant.NotAConstant)
874	return FlowInfo.NON_NULL; // constant expression cannot be null	874	return FlowInfo.NON_NULL; // constant expression cannot be null
875		875
876	VariableBinding local = variableBinding(null);	876	VariableBinding var = variableBinding(null);
877	if (local != null)	877	if (var != null)
878	return flowInfo.nullStatus(local);	878	return flowInfo.nullStatus(var);
879	return FlowInfo.NON_NULL;	879	return FlowInfo.NON_NULL;
880	}	880	}
881		881

Lines 39-81 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java (-18 / +18 lines)
39	// TODO: handle all kinds of expressions (cf. also https://bugs.eclipse.org/364326)	39	// TODO: handle all kinds of expressions (cf. also https://bugs.eclipse.org/364326)
40	}	40	}
41		41
42	VariableBinding local = this.left.variableBinding(scope);	42	VariableBinding var = this.left.variableBinding(scope);
43	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	43	if (var != null && (var.type.tagBits & TagBits.IsBaseType) == 0) {
44	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, rightStatus, this.left);	44	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, var, rightStatus, this.left);
45	}	45	}
46	local = this.right.variableBinding(scope);	46	var = this.right.variableBinding(scope);
47	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	47	if (var != null && (var.type.tagBits & TagBits.IsBaseType) == 0) {
48	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, leftStatus, this.right);	48	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, var, leftStatus, this.right);
49	}	49	}
50	}	50	}
51	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, VariableBinding local, int nullStatus, Expression reference) {	51	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, VariableBinding var, int nullStatus, Expression reference) {
52	switch (nullStatus) {	52	switch (nullStatus) {
53	case FlowInfo.NULL :	53	case FlowInfo.NULL :
54	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	54	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
55	flowContext.recordUsingNullReference(scope, local, reference,	55	flowContext.recordUsingNullReference(scope, var, reference,
56	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);	56	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);
57	initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set	57	initsWhenTrue.markAsComparedEqualToNull(var); // from thereon it is set
58	initsWhenFalse.markAsComparedEqualToNonNull(local); // from thereon it is set	58	initsWhenFalse.markAsComparedEqualToNonNull(var); // from thereon it is set
59	} else {	59	} else {
60	flowContext.recordUsingNullReference(scope, local, reference,	60	flowContext.recordUsingNullReference(scope, var, reference,
61	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);	61	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);
62	initsWhenTrue.markAsComparedEqualToNonNull(local); // from thereon it is set	62	initsWhenTrue.markAsComparedEqualToNonNull(var); // from thereon it is set
63	initsWhenFalse.markAsComparedEqualToNull(local); // from thereon it is set	63	initsWhenFalse.markAsComparedEqualToNull(var); // from thereon it is set
64	}	64	}
65	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	65	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
66	flowInfo.markedAsNullOrNonNullInAssertExpression(local);	66	flowInfo.markedAsNullOrNonNullInAssertExpression(var);
67	}	67	}
68	break;	68	break;
69	case FlowInfo.NON_NULL :	69	case FlowInfo.NON_NULL :
70	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	70	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
71	flowContext.recordUsingNullReference(scope, local, reference,	71	flowContext.recordUsingNullReference(scope, var, reference,
72	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);	72	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);
73	initsWhenTrue.markAsComparedEqualToNonNull(local); // from thereon it is set	73	initsWhenTrue.markAsComparedEqualToNonNull(var); // from thereon it is set
74	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {	74	if ((flowContext.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) != 0) {
75	initsWhenTrue.markedAsNullOrNonNullInAssertExpression(local);	75	initsWhenTrue.markedAsNullOrNonNullInAssertExpression(var);
76	}	76	}
77	} else {	77	} else {
78	flowContext.recordUsingNullReference(scope, local, reference,	78	flowContext.recordUsingNullReference(scope, var, reference,
79	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);	79	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);
80	}	80	}
81	break;	81	break;

Lines 80-98 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/ConditionalFlowInfo.java (-60 / +60 lines)
80	&& this.initsWhenFalse.isDefinitelyAssigned(var);	80	&& this.initsWhenFalse.isDefinitelyAssigned(var);
81	}	81	}
82		82
83	public boolean isDefinitelyNonNull(VariableBinding local) {	83	public boolean isDefinitelyNonNull(VariableBinding var) {
84	return this.initsWhenTrue.isDefinitelyNonNull(local)	84	return this.initsWhenTrue.isDefinitelyNonNull(var)
85	&& this.initsWhenFalse.isDefinitelyNonNull(local);	85	&& this.initsWhenFalse.isDefinitelyNonNull(var);
86	}	86	}
87		87
88	public boolean isDefinitelyNull(VariableBinding local) {	88	public boolean isDefinitelyNull(VariableBinding var) {
89	return this.initsWhenTrue.isDefinitelyNull(local)	89	return this.initsWhenTrue.isDefinitelyNull(var)
90	&& this.initsWhenFalse.isDefinitelyNull(local);	90	&& this.initsWhenFalse.isDefinitelyNull(var);
91	}	91	}
92		92
93	public boolean isDefinitelyUnknown(VariableBinding local) {	93	public boolean isDefinitelyUnknown(VariableBinding var) {
94	return this.initsWhenTrue.isDefinitelyUnknown(local)	94	return this.initsWhenTrue.isDefinitelyUnknown(var)
95	&& this.initsWhenFalse.isDefinitelyUnknown(local);	95	&& this.initsWhenFalse.isDefinitelyUnknown(var);
96	}	96	}
97		97
98	public boolean isPotentiallyAssigned(VariableBinding var) {	98	public boolean isPotentiallyAssigned(VariableBinding var) {
Lines 100-138 Link Here
100	\|\| this.initsWhenFalse.isPotentiallyAssigned(var);	100	\|\| this.initsWhenFalse.isPotentiallyAssigned(var);
101	}	101	}
102		102
103	public boolean isPotentiallyNonNull(VariableBinding local) {	103	public boolean isPotentiallyNonNull(VariableBinding var) {
104	return this.initsWhenTrue.isPotentiallyNonNull(local)	104	return this.initsWhenTrue.isPotentiallyNonNull(var)
105	\|\| this.initsWhenFalse.isPotentiallyNonNull(local);	105	\|\| this.initsWhenFalse.isPotentiallyNonNull(var);
106	}	106	}
107		107
108	public boolean isPotentiallyNull(VariableBinding local) {	108	public boolean isPotentiallyNull(VariableBinding var) {
109	return this.initsWhenTrue.isPotentiallyNull(local)	109	return this.initsWhenTrue.isPotentiallyNull(var)
110	\|\| this.initsWhenFalse.isPotentiallyNull(local);	110	\|\| this.initsWhenFalse.isPotentiallyNull(var);
111	}	111	}
112		112
113	public boolean isPotentiallyUnknown(VariableBinding local) {	113	public boolean isPotentiallyUnknown(VariableBinding var) {
114	return this.initsWhenTrue.isPotentiallyUnknown(local)	114	return this.initsWhenTrue.isPotentiallyUnknown(var)
115	\|\| this.initsWhenFalse.isPotentiallyUnknown(local);	115	\|\| this.initsWhenFalse.isPotentiallyUnknown(var);
116	}	116	}
117		117
118	public boolean isProtectedNonNull(VariableBinding local) {	118	public boolean isProtectedNonNull(VariableBinding var) {
119	return this.initsWhenTrue.isProtectedNonNull(local)	119	return this.initsWhenTrue.isProtectedNonNull(var)
120	&& this.initsWhenFalse.isProtectedNonNull(local);	120	&& this.initsWhenFalse.isProtectedNonNull(var);
121	}	121	}
122		122
123	public boolean isProtectedNull(VariableBinding local) {	123	public boolean isProtectedNull(VariableBinding var) {
124	return this.initsWhenTrue.isProtectedNull(local)	124	return this.initsWhenTrue.isProtectedNull(var)
125	&& this.initsWhenFalse.isProtectedNull(local);	125	&& this.initsWhenFalse.isProtectedNull(var);
126	}	126	}
127		127
128	public void markAsComparedEqualToNonNull(VariableBinding local) {	128	public void markAsComparedEqualToNonNull(VariableBinding var) {
129	this.initsWhenTrue.markAsComparedEqualToNonNull(local);	129	this.initsWhenTrue.markAsComparedEqualToNonNull(var);
130	this.initsWhenFalse.markAsComparedEqualToNonNull(local);	130	this.initsWhenFalse.markAsComparedEqualToNonNull(var);
131	}	131	}
132		132
133	public void markAsComparedEqualToNull(VariableBinding local) {	133	public void markAsComparedEqualToNull(VariableBinding var) {
134	this.initsWhenTrue.markAsComparedEqualToNull(local);	134	this.initsWhenTrue.markAsComparedEqualToNull(var);
135	this.initsWhenFalse.markAsComparedEqualToNull(local);	135	this.initsWhenFalse.markAsComparedEqualToNull(var);
136	}	136	}
137		137
138	public void markAsDefinitelyAssigned(VariableBinding var) {	138	public void markAsDefinitelyAssigned(VariableBinding var) {
Lines 140-158 Link Here
140	this.initsWhenFalse.markAsDefinitelyAssigned(var);	140	this.initsWhenFalse.markAsDefinitelyAssigned(var);
141	}	141	}
142		142
143	public void markAsDefinitelyNonNull(VariableBinding local) {	143	public void markAsDefinitelyNonNull(VariableBinding var) {
144	this.initsWhenTrue.markAsDefinitelyNonNull(local);	144	this.initsWhenTrue.markAsDefinitelyNonNull(var);
145	this.initsWhenFalse.markAsDefinitelyNonNull(local);	145	this.initsWhenFalse.markAsDefinitelyNonNull(var);
146	}	146	}
147		147
148	public void markAsDefinitelyNull(VariableBinding local) {	148	public void markAsDefinitelyNull(VariableBinding var) {
149	this.initsWhenTrue.markAsDefinitelyNull(local);	149	this.initsWhenTrue.markAsDefinitelyNull(var);
150	this.initsWhenFalse.markAsDefinitelyNull(local);	150	this.initsWhenFalse.markAsDefinitelyNull(var);
151	}	151	}
152		152
153	public void resetNullInfo(VariableBinding local) {	153	public void resetNullInfo(VariableBinding var) {
154	this.initsWhenTrue.resetNullInfo(local);	154	this.initsWhenTrue.resetNullInfo(var);
155	this.initsWhenFalse.resetNullInfo(local);	155	this.initsWhenFalse.resetNullInfo(var);
156	}	156	}
157		157
158	public void resetNullInfoForFields() {	158	public void resetNullInfoForFields() {
Lines 170-193 Link Here
170	this.initsWhenFalse.addConstantFieldsMask(other);	170	this.initsWhenFalse.addConstantFieldsMask(other);
171	}	171	}
172		172
173	public void markPotentiallyNullBit(VariableBinding local) {	173	public void markPotentiallyNullBit(VariableBinding var) {
174	this.initsWhenTrue.markPotentiallyNullBit(local);	174	this.initsWhenTrue.markPotentiallyNullBit(var);
175	this.initsWhenFalse.markPotentiallyNullBit(local);	175	this.initsWhenFalse.markPotentiallyNullBit(var);
176	}	176	}
177		177
178	public void markPotentiallyNonNullBit(VariableBinding local) {	178	public void markPotentiallyNonNullBit(VariableBinding var) {
179	this.initsWhenTrue.markPotentiallyNonNullBit(local);	179	this.initsWhenTrue.markPotentiallyNonNullBit(var);
180	this.initsWhenFalse.markPotentiallyNonNullBit(local);	180	this.initsWhenFalse.markPotentiallyNonNullBit(var);
181	}	181	}
182		182
183	public void markAsDefinitelyUnknown(VariableBinding local) {	183	public void markAsDefinitelyUnknown(VariableBinding var) {
184	this.initsWhenTrue.markAsDefinitelyUnknown(local);	184	this.initsWhenTrue.markAsDefinitelyUnknown(var);
185	this.initsWhenFalse.markAsDefinitelyUnknown(local);	185	this.initsWhenFalse.markAsDefinitelyUnknown(var);
186	}	186	}
187		187
188	public void markPotentiallyUnknownBit(VariableBinding local) {	188	public void markPotentiallyUnknownBit(VariableBinding var) {
189	this.initsWhenTrue.markPotentiallyUnknownBit(local);	189	this.initsWhenTrue.markPotentiallyUnknownBit(var);
190	this.initsWhenFalse.markPotentiallyUnknownBit(local);	190	this.initsWhenFalse.markPotentiallyUnknownBit(var);
191	}	191	}
192		192
193	public FlowInfo setReachMode(int reachMode) {	193	public FlowInfo setReachMode(int reachMode) {
Lines 243-260 Link Here
243	mergedWith(this.initsWhenFalse.unconditionalInits());	243	mergedWith(this.initsWhenFalse.unconditionalInits());
244	}	244	}
245		245
246	public void markedAsNullOrNonNullInAssertExpression(VariableBinding local) {	246	public void markedAsNullOrNonNullInAssertExpression(VariableBinding var) {
247	this.initsWhenTrue.markedAsNullOrNonNullInAssertExpression(local);	247	this.initsWhenTrue.markedAsNullOrNonNullInAssertExpression(var);
248	this.initsWhenFalse.markedAsNullOrNonNullInAssertExpression(local);	248	this.initsWhenFalse.markedAsNullOrNonNullInAssertExpression(var);
249	}	249	}
250		250
251	public boolean isMarkedAsNullOrNonNullInAssertExpression(VariableBinding local) {	251	public boolean isMarkedAsNullOrNonNullInAssertExpression(VariableBinding var) {
252	return (this.initsWhenTrue.isMarkedAsNullOrNonNullInAssertExpression(local)	252	return (this.initsWhenTrue.isMarkedAsNullOrNonNullInAssertExpression(var)
253	\|\| this.initsWhenFalse.isMarkedAsNullOrNonNullInAssertExpression(local));	253	\|\| this.initsWhenFalse.isMarkedAsNullOrNonNullInAssertExpression(var));
254	}	254	}
255		255
256	public void resetAssignmentInfo(LocalVariableBinding local) {	256	public void resetAssignmentInfo(LocalVariableBinding var) {
257	this.initsWhenTrue.resetAssignmentInfo(local);	257	this.initsWhenTrue.resetAssignmentInfo(var);
258	this.initsWhenFalse.resetAssignmentInfo(local);	258	this.initsWhenFalse.resetAssignmentInfo(var);
259	}	259	}
260	}	260	}