Attachment #206514 for bug #247564

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




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





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


		"",/* expected error */
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// 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 field22;\n" +
			"  }\n" +
			"}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 13)\n" + 
		"	if (field3 == null && field3.toString() == \"\"){}\n" + 
		"	                      ^^^^^^\n" + 
		"Potential null pointer access: The field field3 may be null at this location\n" + 
		"----------\n"
	);
}
}




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

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




	// record setting a variable: various scenarii are possible, setting an array reference,
// a field reference, a blank final field reference, a field of an enclosing instance or
// just a local variable.
	VariableBinding var = this.lhs.variableBinding();
	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
		this.expression.checkNPE(currentScope, flowContext, flowInfo);
	}
	flowInfo = ((Reference) this.lhs)
		.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
		.unconditionalInits();
	if (var instanceof LocalVariableBinding) {
		LocalVariableBinding local = (LocalVariableBinding) var;
		LocalVariableBinding previousTrackerBinding = null;
		if (local.closeTracker != null) {
			// Assigning to a variable already holding an AutoCloseable, has it been closed before?

		FakedTrackingVariable.handleResourceAssignment(flowInfo, this, this.expression, local, previousTrackerBinding);
	}
	int nullStatus = this.expression.nullStatus(flowInfo);
	if (var != null && (var.type.tagBits & TagBits.IsBaseType) == 0) {
		if (nullStatus == FlowInfo.NULL) {
			flowContext.recordUsingNullReference(currentScope, var, this.lhs,
				FlowContext.CAN_ONLY_NULL | FlowContext.IN_ASSIGNMENT, flowInfo);
		}
	}
	nullStatus = checkAgainstNullAnnotation(currentScope, var, nullStatus);
	if (var != null && (var.type.tagBits & TagBits.IsBaseType) == 0) {
		flowInfo.markNullStatus(var, nullStatus);
		if (flowContext.initsOnFinally != null)
			flowContext.initsOnFinally.markNullStatus(var, nullStatus);
		if (var instanceof FieldBinding && var.isFinal() && ((FieldBinding) var).isStatic()) {
			// static final field being assigned. Record its null status for future reference
			// since the flowInfo from a constructor or static block wont be available in a method
			FieldBinding fieldBinding = (FieldBinding) var;
			fieldBinding.setNullStatusForStaticFinalField(nullStatus);
		}
	}
	return flowInfo;
}

public LocalVariableBinding localVariableBinding() {
	return this.lhs.localVariableBinding();
}
public VariableBinding variableBinding() {
	return this.lhs.variableBinding();
}
}

Lines 37-42 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Block.java (+2 lines)
37	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);	37	flowInfo = stat.analyseCode(this.scope, flowContext, flowInfo);
38	}	38	}
39	}	39	}
		40	// don't let the flow info collected for fields from this block persist.
		41	flowInfo.resetNullInfoForFields();
40	if (this.explicitDeclarations > 0) // if block has its own scope analyze tracking vars now:	42	if (this.explicitDeclarations > 0) // if block has its own scope analyze tracking vars now:
41	this.scope.checkUnclosedCloseables(flowInfo, null, null);	43	this.scope.checkUnclosedCloseables(flowInfo, null, null);
42	return flowInfo;	44	return flowInfo;

Lines 33-38 Link Here

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




	}
	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

(-)a/org.eclipse.jdt.core/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	}




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 113-118 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (+3 lines)
113	// NullReferenceTest#test0510	113	// NullReferenceTest#test0510
114	}	114	}
115	manageSyntheticAccessIfNecessary(currentScope, flowInfo);	115	manageSyntheticAccessIfNecessary(currentScope, flowInfo);
		116	// a method call can result in changed values for fields,
		117	// so wipe out null info for fields collected till now.
		118	flowInfo.resetNullInfoForFields();
116	return flowInfo;	119	return flowInfo;
117	}	120	}
118	/**	121	/**




	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 58-64 Link Here

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

Lines 651-657 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java (-11 / +39 lines)
651	// branch, since the previous initializer already got the blame.	651	// branch, since the previous initializer already got the blame.
652	if (staticFieldInfo == FlowInfo.DEAD_END) {	652	if (staticFieldInfo == FlowInfo.DEAD_END) {
653	this.staticInitializerScope.problemReporter().initializerMustCompleteNormally(field);	653	this.staticInitializerScope.problemReporter().initializerMustCompleteNormally(field);
654	staticFieldInfo = FlowInfo.initial(this.maxFieldCount).setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);	654	staticFieldInfo = FlowInfo.initial(this.scope.cumulativeFieldCount).setReachMode(FlowInfo.UNREACHABLE);
655	}	655	}
656	} else {	656	} else {
657	if ((nonStaticFieldInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0)	657	if ((nonStaticFieldInfo.tagBits & FlowInfo.UNREACHABLE_OR_DEAD) != 0)
Lines 667-673 Link Here
667	// branch, since the previous initializer already got the blame.	667	// branch, since the previous initializer already got the blame.
668	if (nonStaticFieldInfo == FlowInfo.DEAD_END) {	668	if (nonStaticFieldInfo == FlowInfo.DEAD_END) {
669	this.initializerScope.problemReporter().initializerMustCompleteNormally(field);	669	this.initializerScope.problemReporter().initializerMustCompleteNormally(field);
670	nonStaticFieldInfo = FlowInfo.initial(this.maxFieldCount).setReachMode(FlowInfo.UNREACHABLE_OR_DEAD);	670	nonStaticFieldInfo = FlowInfo.initial(this.scope.cumulativeFieldCount).setReachMode(FlowInfo.UNREACHABLE);
671	}	671	}
672	}	672	}
673	}	673	}
Lines 683-688 Link Here
683	}	683	}
684	if (this.methods != null) {	684	if (this.methods != null) {
685	UnconditionalFlowInfo outerInfo = flowInfo.unconditionalFieldLessCopy();	685	UnconditionalFlowInfo outerInfo = flowInfo.unconditionalFieldLessCopy();
		686	//int fieldOffset = isLocal ? this.scope.cumulativeFieldCount : this.maxFieldCount;
		687	//int fieldStart = isLocal ? this.scope.localTypeFieldIdStart : 0;
686	FlowInfo constructorInfo = nonStaticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo);	688	FlowInfo constructorInfo = nonStaticFieldInfo.unconditionalInits().discardNonFieldInitializations().addInitializationsFrom(outerInfo);
687	for (int i = 0, count = this.methods.length; i < count; i++) {	689	for (int i = 0, count = this.methods.length; i < count; i++) {
688	AbstractMethodDeclaration method = this.methods[i];	690	AbstractMethodDeclaration method = this.methods[i];
Lines 1038-1045 Link Here
1038	}	1040	}
1039	} while ((current = current.enclosingType()) != null);	1041	} while ((current = current.enclosingType()) != null);
1040	}	1042	}
1041	// this.maxFieldCount might already be set
1042	int localMaxFieldCount = 0;
1043	int lastVisibleFieldID = -1;	1043	int lastVisibleFieldID = -1;
1044	boolean hasEnumConstants = false;	1044	boolean hasEnumConstants = false;
1045	FieldDeclaration[] enumConstantsWithoutBody = null;	1045	FieldDeclaration[] enumConstantsWithoutBody = null;
Lines 1049-1059 Link Here
1049	this.typeParameters[i].resolve(this.scope);	1049	this.typeParameters[i].resolve(this.scope);
1050	}	1050	}
1051	}	1051	}
1052	if (this.memberTypes != null) {	1052	// field count from supertypes should be included in maxFieldCount,
1053	for (int i = 0, count = this.memberTypes.length; i < count; i++) {	1053	// so that a field from supertype doesn't end up with same id as a local variable
1054	this.memberTypes[i].resolve(this.scope);	1054	// in a method being analyzed.
		1055	int superFieldsCount = 0;
		1056	ReferenceBinding superClassBinding = sourceType.superclass;
		1057	while (superClassBinding != null) {
		1058	FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
		1059	if (unResolvedFields != null) {
		1060	superFieldsCount += unResolvedFields.length;
1055	}	1061	}
		1062	superFieldsCount += findFieldCountFromSuperInterfaces(superClassBinding.superInterfaces());
		1063	superClassBinding = superClassBinding.superclass();
1056	}	1064	}
		1065	ReferenceBinding[] superInterfacesBinding = this.binding.superInterfaces;
		1066	superFieldsCount += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		1067	this.scope.cumulativeFieldCount += superFieldsCount;
1057	if (this.fields != null) {	1068	if (this.fields != null) {
1058	for (int i = 0, count = this.fields.length; i < count; i++) {	1069	for (int i = 0, count = this.fields.length; i < count; i++) {
1059	FieldDeclaration field = this.fields[i];	1070	FieldDeclaration field = this.fields[i];
Lines 1074-1086 Link Here
1074	this.ignoreFurtherInvestigation = true;	1085	this.ignoreFurtherInvestigation = true;
1075	continue;	1086	continue;
1076	}	1087	}
		1088	field.binding.id += superFieldsCount;
1077	if (needSerialVersion	1089	if (needSerialVersion
1078	&& ((fieldBinding.modifiers & (ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal)) == (ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal))	1090	&& ((fieldBinding.modifiers & (ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal)) == (ClassFileConstants.AccStatic \| ClassFileConstants.AccFinal))
1079	&& CharOperation.equals(TypeConstants.SERIALVERSIONUID, fieldBinding.name)	1091	&& CharOperation.equals(TypeConstants.SERIALVERSIONUID, fieldBinding.name)
1080	&& TypeBinding.LONG == fieldBinding.type) {	1092	&& TypeBinding.LONG == fieldBinding.type) {
1081	needSerialVersion = false;	1093	needSerialVersion = false;
1082	}	1094	}
1083	localMaxFieldCount++;
1084	lastVisibleFieldID = field.binding.id;	1095	lastVisibleFieldID = field.binding.id;
1085	break;	1096	break;
1086		1097
Lines 1090-1098 Link Here
1090	}	1101	}
1091	field.resolve(field.isStatic() ? this.staticInitializerScope : this.initializerScope);	1102	field.resolve(field.isStatic() ? this.staticInitializerScope : this.initializerScope);
1092	}	1103	}
1093	}	1104	}
1094	if (this.maxFieldCount < localMaxFieldCount) {	1105	// if (this.maxFieldCount < localMaxFieldCount) {
1095	this.maxFieldCount = localMaxFieldCount;	1106	// this.maxFieldCount = localMaxFieldCount;
		1107	// }
		1108	this.maxFieldCount = this.scope.cumulativeFieldCount;
		1109	if (this.memberTypes != null) {
		1110	for (int i = 0, count = this.memberTypes.length; i < count; i++) {
		1111	this.memberTypes[i].resolve(this.scope);
		1112	}
1096	}	1113	}
1097	if (needSerialVersion) {	1114	if (needSerialVersion) {
1098	//check that the current type doesn't extend javax.rmi.CORBA.Stub	1115	//check that the current type doesn't extend javax.rmi.CORBA.Stub
Lines 1180-1185 Link Here
1180	}	1197	}
1181	}	1198	}
1182		1199
		1200	private int findFieldCountFromSuperInterfaces(ReferenceBinding[] superinterfaces) {
		1201	int numOfFields = 0;
		1202	if (superinterfaces == null)
		1203	return numOfFields ;
		1204	for (int i = 0; i < superinterfaces.length; i++) {
		1205	numOfFields += superinterfaces[i].fieldCount();
		1206	numOfFields += findFieldCountFromSuperInterfaces(superinterfaces[i].superInterfaces());
		1207	}
		1208	return numOfFields;
		1209	}
		1210
1183	/**	1211	/**
1184	* Resolve a local type declaration	1212	* Resolve a local type declaration
1185	*/	1213	*/





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_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(local, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
									flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);

							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_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(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_BY_NULLANALYSIS);
									}
									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_BY_NULLANALYSIS);
								}
							} else {
								if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
									scope.problemReporter().variableNonNullComparedToNull(local, reference);
								}
								if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
									flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);

							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_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(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_BY_NULLANALYSIS);
									}
									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;
}




 *      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_BY_NULLANALYSIS);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableNonNullComparedToNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);

				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_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(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_BY_NULLANALYSIS);
						}
						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);

/**
 * Resets the definite and potential initialization info for the given local variable




	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_BY_NULLANALYSIS);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableNonNullComparedToNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);

			} 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_BY_NULLANALYSIS);
					}
				} else {
					if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
						scope.problemReporter().variableNullComparedToNonNull(local, reference);
					}
					if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
						flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);

				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_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(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_BY_NULLANALYSIS);
						}
						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)

	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;

}

// TODO (Ayush) Check why this method does not return true for protected non null (1111)
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;

}

// TODO (Ayush) Check why this method does not return true for protected null
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;
    	// position is zero-based
    	if (local instanceof FieldBinding) {
    		this.markNullStatus(local, FlowInfo.POTENTIALLY_NON_NULL);
    		return;
    	} else {
    		position = local.id + this.maxFieldCount;
    	}
    	if (position < BitCacheSize) { // use bits
    		// set assigned non null
    		this.nullBit1 |= (mask = 1L << position);
    		this.nullBit3 |= 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;
    	// 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
    		// mark assigned null
    		this.nullBit1 |= (mask = 1L << position);
    		this.nullBit2 |= 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;
		// position is zero-based
		if (local instanceof FieldBinding) {
			position = local.id;
		} else {
			position = local.id + this.maxFieldCount;
		}
		if (position < BitCacheSize) {
			// use bits
			// mark assigned null
			this.nullBit1 |= (mask = 1L << position);

	}
}

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

Lines 39-49 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java (-2 / +26 lines)
39	public TypeDeclaration referenceContext;	39	public TypeDeclaration referenceContext;
40	public TypeReference superTypeReference;	40	public TypeReference superTypeReference;
41	java.util.ArrayList deferredBoundChecks;	41	java.util.ArrayList deferredBoundChecks;
42		42	public int cumulativeFieldCount; // cumulative field count from all enclosing types, used to build unique field id's for member types.
		43	public int localTypeFieldIdStart;
43	public ClassScope(Scope parent, TypeDeclaration context) {	44	public ClassScope(Scope parent, TypeDeclaration context) {
44	super(Scope.CLASS_SCOPE, parent);	45	super(Scope.CLASS_SCOPE, parent);
45	this.referenceContext = context;	46	this.referenceContext = context;
46	this.deferredBoundChecks = null; // initialized if required	47	this.deferredBoundChecks = null; // initialized if required
		48	this.localTypeFieldIdStart = this.cumulativeFieldCount = 0;
47	}	49	}
48		50
49	void buildAnonymousTypeBinding(SourceTypeBinding enclosingType, ReferenceBinding supertype) {	51	void buildAnonymousTypeBinding(SourceTypeBinding enclosingType, ReferenceBinding supertype) {
Lines 80-85 Link Here
80	}	82	}
81	}	83	}
82	}	84	}
		85	this.cumulativeFieldCount += outerMostMethodScope().analysisIndex;
		86	this.localTypeFieldIdStart = outerMostMethodScope().analysisIndex;
83	connectMemberTypes();	87	connectMemberTypes();
84	buildFieldsAndMethods();	88	buildFieldsAndMethods();
85	anonymousType.faultInTypesForFieldsAndMethods();	89	anonymousType.faultInTypesForFieldsAndMethods();
Lines 109-114 Link Here
109	FieldBinding[] fieldBindings = new FieldBinding[count];	113	FieldBinding[] fieldBindings = new FieldBinding[count];
110	HashtableOfObject knownFieldNames = new HashtableOfObject(count);	114	HashtableOfObject knownFieldNames = new HashtableOfObject(count);
111	count = 0;	115	count = 0;
		116	ClassScope enclosingClass = this.enclosingClassScope();
		117	if (enclosingClass != null) {
		118	this.cumulativeFieldCount += enclosingClass.cumulativeFieldCount;
		119	}
		120	// SourceTypeBinding enclosingSourceType = this.enclosingSourceType();
		121	// if (enclosingSourceType != null) {
		122	// ReferenceBinding superClassBinding = sourceType.superclass;
		123	// while (superClassBinding != null) {
		124	// FieldBinding[] unResolvedFields = superClassBinding.unResolvedFields();
		125	// if (unResolvedFields != null) {
		126	// this.cumulativeFieldCount += unResolvedFields.length;
		127	// }
		128	// superClassBinding = superClassBinding.superclass();
		129	// }
		130	// ReferenceBinding[] superInterfacesBinding = enclosingSourceType.superInterfaces;
		131	// this.cumulativeFieldCount += findFieldCountFromSuperInterfaces(superInterfacesBinding);
		132	// }
112	for (int i = 0; i < size; i++) {	133	for (int i = 0; i < size; i++) {
113	FieldDeclaration field = fields[i];	134	FieldDeclaration field = fields[i];
114	if (field.getKind() == AbstractVariableDeclaration.INITIALIZER) {	135	if (field.getKind() == AbstractVariableDeclaration.INITIALIZER) {
Lines 116-122 Link Here
116	// now this error reporting is moved into the parser itself. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=212713	137	// now this error reporting is moved into the parser itself. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=212713
117	} else {	138	} else {
118	FieldBinding fieldBinding = new FieldBinding(field, null, field.modifiers \| ExtraCompilerModifiers.AccUnresolved, sourceType);	139	FieldBinding fieldBinding = new FieldBinding(field, null, field.modifiers \| ExtraCompilerModifiers.AccUnresolved, sourceType);
119	fieldBinding.id = count;	140	fieldBinding.id = count + this.cumulativeFieldCount;
120	// field's type will be resolved when needed for top level types	141	// field's type will be resolved when needed for top level types
121	checkAndSetModifiersForField(fieldBinding, field);	142	checkAndSetModifiersForField(fieldBinding, field);
122		143
Lines 144-149 Link Here
144	// remove duplicate fields	165	// remove duplicate fields
145	if (count != fieldBindings.length)	166	if (count != fieldBindings.length)
146	System.arraycopy(fieldBindings, 0, fieldBindings = new FieldBinding[count], 0, count);	167	System.arraycopy(fieldBindings, 0, fieldBindings = new FieldBinding[count], 0, count);
		168	this.cumulativeFieldCount += count;
147	sourceType.tagBits &= ~(TagBits.AreFieldsSorted\|TagBits.AreFieldsComplete); // in case some static imports reached already into this type	169	sourceType.tagBits &= ~(TagBits.AreFieldsSorted\|TagBits.AreFieldsComplete); // in case some static imports reached already into this type
148	sourceType.setFields(fieldBindings);	170	sourceType.setFields(fieldBindings);
149	}	171	}
Lines 226-231 Link Here
226	checkParameterizedTypeBounds();	248	checkParameterizedTypeBounds();
227	checkParameterizedSuperTypeCollisions();	249	checkParameterizedSuperTypeCollisions();
228	}	250	}
		251	this.cumulativeFieldCount += outerMostMethodScope().analysisIndex;
		252	this.localTypeFieldIdStart = outerMostMethodScope().analysisIndex;
229	buildFieldsAndMethods();	253	buildFieldsAndMethods();
230	localType.faultInTypesForFieldsAndMethods();	254	localType.faultInTypesForFieldsAndMethods();
231		255




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




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) {
	if ((location.bits & ASTNode.FirstAssignmentToLocal) != 0) // https://bugs.eclipse.org/338303 - Warning about Redundant assignment conflicts with definite assignment
		return;
	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

(-)a/org.eclipse.jdt.core/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

Return to bug 247564

Lines 1267-1272 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java (+20 lines)
1267	/** @since 3.4 */	1267	/** @since 3.4 */
1268	int UnusedTypeArgumentsForConstructorInvocation = MethodRelated + 660;	1268	int UnusedTypeArgumentsForConstructorInvocation = MethodRelated + 660;
1269		1269
		1270	/**
		1271	* Null analysis for fields
		1272	*/
		1273	/** @since 3.8*/
		1274	int NullFieldReference = Internal + FieldRelated + 670;
		1275	/** @since 3.8*/
		1276	int PotentialNullFieldReference = Internal + FieldRelated + 671;
		1277	/** @since 3.8*/
		1278	int RedundantNullCheckOnNullField = Internal + FieldRelated + 672;
		1279	/** @since 3.8*/
		1280	int NullFieldComparisonYieldsFalse = Internal + FieldRelated + 673;
		1281	/** @since 3.8*/
		1282	int RedundantNullCheckOnNonNullField = Internal + FieldRelated + 674;
		1283	/** @since 3.8*/
		1284	int NonNullFieldComparisonYieldsFalse = Internal + FieldRelated + 675;
		1285	/** @since 3.8*/
		1286	int RedundantFieldNullAssignment = Internal + FieldRelated + 676;
		1287	/** @since 3.8*/
		1288	int NullFieldInstanceofYieldsFalse = Internal + FieldRelated + 677;
		1289
1270	/**	1290	/**
1271	* Corrupted binaries	1291	* Corrupted binaries
1272	*/	1292	*/

Lines 807-812 Link Here

(-)a/org.eclipse.jdt.core/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 106-111 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (-48 / +105 lines)
106	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;	106	import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
107	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	107	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
108	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;	108	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
		109	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
109	import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;	110	import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
110	import org.eclipse.jdt.internal.compiler.parser.JavadocTagConstants;	111	import org.eclipse.jdt.internal.compiler.parser.JavadocTagConstants;
111	import org.eclipse.jdt.internal.compiler.parser.Parser;	112	import org.eclipse.jdt.internal.compiler.parser.Parser;
Lines 284-300 Link Here
284	return CompilerOptions.VarargsArgumentNeedCast;	285	return CompilerOptions.VarargsArgumentNeedCast;
285		286
286	case IProblem.NullLocalVariableReference:	287	case IProblem.NullLocalVariableReference:
		288	case IProblem.NullFieldReference:
287	return CompilerOptions.NullReference;	289	return CompilerOptions.NullReference;
288		290
289	case IProblem.PotentialNullLocalVariableReference:	291	case IProblem.PotentialNullLocalVariableReference:
		292	case IProblem.PotentialNullFieldReference:
290	return CompilerOptions.PotentialNullReference;	293	return CompilerOptions.PotentialNullReference;
291		294
292	case IProblem.RedundantLocalVariableNullAssignment:	295	case IProblem.RedundantLocalVariableNullAssignment:
		296	case IProblem.RedundantFieldNullAssignment:
293	case IProblem.RedundantNullCheckOnNonNullLocalVariable:	297	case IProblem.RedundantNullCheckOnNonNullLocalVariable:
294	case IProblem.RedundantNullCheckOnNullLocalVariable:	298	case IProblem.RedundantNullCheckOnNullLocalVariable:
295	case IProblem.NonNullLocalVariableComparisonYieldsFalse:	299	case IProblem.NonNullLocalVariableComparisonYieldsFalse:
296	case IProblem.NullLocalVariableComparisonYieldsFalse:	300	case IProblem.NullLocalVariableComparisonYieldsFalse:
297	case IProblem.NullLocalVariableInstanceofYieldsFalse:	301	case IProblem.NullLocalVariableInstanceofYieldsFalse:
		302	case IProblem.NullFieldInstanceofYieldsFalse:
		303	case IProblem.RedundantNullCheckOnNonNullField:
		304	case IProblem.RedundantNullCheckOnNullField:
		305	case IProblem.NonNullFieldComparisonYieldsFalse:
		306	case IProblem.NullFieldComparisonYieldsFalse:
298	return CompilerOptions.RedundantNullCheck;	307	return CompilerOptions.RedundantNullCheck;
299		308
300	case IProblem.BoxingConversion :	309	case IProblem.BoxingConversion :
Lines 5000-5109 Link Here
5000	}	5009	}
5001	}	5010	}
5002		5011
5003	public void localVariableNonNullComparedToNull(LocalVariableBinding local, ASTNode location) {	5012	public void variableNonNullComparedToNull(VariableBinding variable, ASTNode location) {
5004	int severity = computeSeverity(IProblem.NonNullLocalVariableComparisonYieldsFalse);	5013	int problem;
		5014	if (variable instanceof FieldBinding) {
		5015	problem = IProblem.NonNullFieldComparisonYieldsFalse;
		5016	} else {
		5017	problem = IProblem.NonNullLocalVariableComparisonYieldsFalse;
		5018	}
		5019	int severity = computeSeverity(problem);
5005	if (severity == ProblemSeverities.Ignore) return;	5020	if (severity == ProblemSeverities.Ignore) return;
5006	String[] arguments = new String[] {new String(local.name) };	5021	String[] arguments = new String[] {new String(variable.name) };
5007	this.handle(	5022	this.handle(
5008	IProblem.NonNullLocalVariableComparisonYieldsFalse,	5023	problem,
5009	arguments,	5024	arguments,
5010	arguments,	5025	arguments,
5011	severity,	5026	severity,
5012	nodeSourceStart(local, location),	5027	nodeSourceStart(variable, location),
5013	nodeSourceEnd(local, location));	5028	nodeSourceEnd(variable, location));
5014	}	5029	}
5015		5030
5016	public void localVariableNullComparedToNonNull(LocalVariableBinding local, ASTNode location) {	5031	public void variableNullComparedToNonNull(VariableBinding variable, ASTNode location) {
5017	int severity = computeSeverity(IProblem.NullLocalVariableComparisonYieldsFalse);	5032	int problem;
		5033	if (variable instanceof FieldBinding) {
		5034	problem = IProblem.NullFieldComparisonYieldsFalse;
		5035	} else {
		5036	problem = IProblem.NullLocalVariableComparisonYieldsFalse;
		5037	}
		5038	int severity = computeSeverity(problem);
5018	if (severity == ProblemSeverities.Ignore) return;	5039	if (severity == ProblemSeverities.Ignore) return;
5019	String[] arguments = new String[] {new String(local.name) };	5040	String[] arguments = new String[] {new String(variable.name) };
5020	this.handle(	5041	this.handle(
5021	IProblem.NullLocalVariableComparisonYieldsFalse,	5042	problem,
5022	arguments,	5043	arguments,
5023	arguments,	5044	arguments,
5024	severity,	5045	severity,
5025	nodeSourceStart(local, location),	5046	nodeSourceStart(variable, location),
5026	nodeSourceEnd(local, location));	5047	nodeSourceEnd(variable, location));
5027	}	5048	}
5028		5049
5029	public void localVariableNullInstanceof(LocalVariableBinding local, ASTNode location) {	5050	public void variableNullInstanceof(VariableBinding variable, ASTNode location) {
5030	int severity = computeSeverity(IProblem.NullLocalVariableInstanceofYieldsFalse);	5051	int problem;
		5052	if (variable instanceof FieldBinding) {
		5053	problem = IProblem.NullFieldInstanceofYieldsFalse;
		5054	} else {
		5055	problem = IProblem.NullLocalVariableInstanceofYieldsFalse;
		5056	}
		5057	int severity = computeSeverity(problem);
5031	if (severity == ProblemSeverities.Ignore) return;	5058	if (severity == ProblemSeverities.Ignore) return;
5032	String[] arguments = new String[] {new String(local.name) };	5059	String[] arguments = new String[] {new String(variable.name) };
5033	this.handle(	5060	this.handle(
5034	IProblem.NullLocalVariableInstanceofYieldsFalse,	5061	problem,
5035	arguments,	5062	arguments,
5036	arguments,	5063	arguments,
5037	severity,	5064	severity,
5038	nodeSourceStart(local, location),	5065	nodeSourceStart(variable, location),
5039	nodeSourceEnd(local, location));	5066	nodeSourceEnd(variable, location));
5040	}	5067	}
5041		5068
5042	public void localVariableNullReference(LocalVariableBinding local, ASTNode location) {	5069	public void variableNullReference(VariableBinding variable, ASTNode location) {
5043	int severity = computeSeverity(IProblem.NullLocalVariableReference);	5070	int problem;
		5071	if (variable instanceof FieldBinding) {
		5072	problem = IProblem.NullFieldReference;
		5073	} else {
		5074	problem = IProblem.NullLocalVariableReference;
		5075	}
		5076	int severity = computeSeverity(problem);
5044	if (severity == ProblemSeverities.Ignore) return;	5077	if (severity == ProblemSeverities.Ignore) return;
5045	String[] arguments = new String[] {new String(local.name) };	5078	String[] arguments = new String[] {new String(variable.name) };
5046	this.handle(	5079	this.handle(
5047	IProblem.NullLocalVariableReference,	5080	problem,
5048	arguments,	5081	arguments,
5049	arguments,	5082	arguments,
5050	severity,	5083	severity,
5051	nodeSourceStart(local, location),	5084	nodeSourceStart(variable, location),
5052	nodeSourceEnd(local, location));	5085	nodeSourceEnd(variable, location));
5053	}	5086	}
5054		5087
5055	public void localVariablePotentialNullReference(LocalVariableBinding local, ASTNode location) {	5088	public void variablePotentialNullReference(VariableBinding variable, ASTNode location) {
5056	int severity = computeSeverity(IProblem.PotentialNullLocalVariableReference);	5089	int problem;
		5090	if (variable instanceof FieldBinding) {
		5091	problem = IProblem.PotentialNullFieldReference;
		5092	} else {
		5093	problem = IProblem.PotentialNullLocalVariableReference;
		5094	}
		5095	int severity = computeSeverity(problem);
5057	if (severity == ProblemSeverities.Ignore) return;	5096	if (severity == ProblemSeverities.Ignore) return;
5058	String[] arguments = new String[] {new String(local.name)};	5097	String[] arguments = new String[] {new String(variable.name)};
5059	this.handle(	5098	this.handle(
5060	IProblem.PotentialNullLocalVariableReference,	5099	problem,
5061	arguments,	5100	arguments,
5062	arguments,	5101	arguments,
5063	severity,	5102	severity,
5064	nodeSourceStart(local, location),	5103	nodeSourceStart(variable, location),
5065	nodeSourceEnd(local, location));	5104	nodeSourceEnd(variable, location));
5066	}	5105	}
5067		5106
5068	public void localVariableRedundantCheckOnNonNull(LocalVariableBinding local, ASTNode location) {	5107	public void variableRedundantCheckOnNonNull(VariableBinding variable, ASTNode location) {
5069	int severity = computeSeverity(IProblem.RedundantNullCheckOnNonNullLocalVariable);	5108	int problem;
		5109	if (variable instanceof FieldBinding) {
		5110	problem = IProblem.RedundantNullCheckOnNonNullField;
		5111	} else {
		5112	problem = IProblem.RedundantNullCheckOnNonNullLocalVariable;
		5113	}
		5114	int severity = computeSeverity(problem);
5070	if (severity == ProblemSeverities.Ignore) return;	5115	if (severity == ProblemSeverities.Ignore) return;
5071	String[] arguments = new String[] {new String(local.name) };	5116	String[] arguments = new String[] {new String(variable.name) };
5072	this.handle(	5117	this.handle(
5073	IProblem.RedundantNullCheckOnNonNullLocalVariable,	5118	problem,
5074	arguments,	5119	arguments,
5075	arguments,	5120	arguments,
5076	severity,	5121	severity,
5077	nodeSourceStart(local, location),	5122	nodeSourceStart(variable, location),
5078	nodeSourceEnd(local, location));	5123	nodeSourceEnd(variable, location));
5079	}	5124	}
5080		5125
5081	public void localVariableRedundantCheckOnNull(LocalVariableBinding local, ASTNode location) {	5126	public void variableRedundantCheckOnNull (VariableBinding variable, ASTNode location) {
5082	int severity = computeSeverity(IProblem.RedundantNullCheckOnNullLocalVariable);	5127	int problem;
		5128	if (variable instanceof FieldBinding) {
		5129	problem = IProblem.RedundantNullCheckOnNullField;
		5130	} else {
		5131	problem = IProblem.RedundantNullCheckOnNullLocalVariable;
		5132	}
		5133	int severity = computeSeverity(problem);
5083	if (severity == ProblemSeverities.Ignore) return;	5134	if (severity == ProblemSeverities.Ignore) return;
5084	String[] arguments = new String[] {new String(local.name) };	5135	String[] arguments = new String[] {new String(variable.name) };
5085	this.handle(	5136	this.handle(
5086	IProblem.RedundantNullCheckOnNullLocalVariable,	5137	problem,
5087	arguments,	5138	arguments,
5088	arguments,	5139	arguments,
5089	severity,	5140	severity,
5090	nodeSourceStart(local, location),	5141	nodeSourceStart(variable, location),
5091	nodeSourceEnd(local, location));	5142	nodeSourceEnd(variable, location));
5092	}	5143	}
5093		5144
5094	public void localVariableRedundantNullAssignment(LocalVariableBinding local, ASTNode location) {	5145	public void variableRedundantNullAssignment (VariableBinding variable, ASTNode location) {
5095	if ((location.bits & ASTNode.FirstAssignmentToLocal) != 0) // https://bugs.eclipse.org/338303 - Warning about Redundant assignment conflicts with definite assignment	5146	if ((location.bits & ASTNode.FirstAssignmentToLocal) != 0) // https://bugs.eclipse.org/338303 - Warning about Redundant assignment conflicts with definite assignment
5096	return;	5147	return;
5097	int severity = computeSeverity(IProblem.RedundantLocalVariableNullAssignment);	5148	int problem;
		5149	if (variable instanceof FieldBinding) {
		5150	problem = IProblem.RedundantFieldNullAssignment;
		5151	} else {
		5152	problem = IProblem.RedundantLocalVariableNullAssignment;
		5153	}
		5154	int severity = computeSeverity(problem);
5098	if (severity == ProblemSeverities.Ignore) return;	5155	if (severity == ProblemSeverities.Ignore) return;
5099	String[] arguments = new String[] {new String(local.name) };	5156	String[] arguments = new String[] {new String(variable.name) };
5100	this.handle(	5157	this.handle(
5101	IProblem.RedundantLocalVariableNullAssignment,	5158	problem,
5102	arguments,	5159	arguments,
5103	arguments,	5160	arguments,
5104	severity,	5161	severity,
5105	nodeSourceStart(local, location),	5162	nodeSourceStart(variable, location),
5106	nodeSourceEnd(local, location));	5163	nodeSourceEnd(variable, location));
5107	}	5164	}
5108		5165
5109	public void methodMustOverride(AbstractMethodDeclaration method, long complianceLevel) {	5166	public void methodMustOverride(AbstractMethodDeclaration method, long complianceLevel) {

Lines 580-585 Link Here

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

Lines 717-722 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (+16 lines)
717	expectedProblemAttributes.put("NonGenericConstructor", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	717	expectedProblemAttributes.put("NonGenericConstructor", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
718	expectedProblemAttributes.put("NonGenericMethod", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	718	expectedProblemAttributes.put("NonGenericMethod", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
719	expectedProblemAttributes.put("NonGenericType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	719	expectedProblemAttributes.put("NonGenericType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		720	expectedProblemAttributes.put("NonNullFieldComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
720	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	721	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
721	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	722	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
722	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	723	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
Lines 729-734 Link Here
729	expectedProblemAttributes.put("NotVisibleField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	730	expectedProblemAttributes.put("NotVisibleField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
730	expectedProblemAttributes.put("NotVisibleMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	731	expectedProblemAttributes.put("NotVisibleMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
731	expectedProblemAttributes.put("NotVisibleType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	732	expectedProblemAttributes.put("NotVisibleType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		733	expectedProblemAttributes.put("NullFieldComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		734	expectedProblemAttributes.put("NullFieldInstanceofYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		735	expectedProblemAttributes.put("NullFieldReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
732	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	736	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
733	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	737	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
734	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	738	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
Lines 770-775 Link Here
770	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));	774	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));
771	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	775	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
772	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	776	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		777	expectedProblemAttributes.put("PotentialNullFieldReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
773	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	778	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
774	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	779	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
775	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	780	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
Lines 778-785 Link Here
778	expectedProblemAttributes.put("RedefinedArgument", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	783	expectedProblemAttributes.put("RedefinedArgument", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
779	expectedProblemAttributes.put("RedefinedLocal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	784	expectedProblemAttributes.put("RedefinedLocal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
780	expectedProblemAttributes.put("RedundantSpecificationOfTypeArguments", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));	785	expectedProblemAttributes.put("RedundantSpecificationOfTypeArguments", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
		786	expectedProblemAttributes.put("RedundantFieldNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
781	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	787	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		788	expectedProblemAttributes.put("RedundantNullCheckOnNonNullField", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
782	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	789	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		790	expectedProblemAttributes.put("RedundantNullCheckOnNullField", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
783	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	791	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
784	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));	792	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
785	expectedProblemAttributes.put("ReferenceToForwardField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	793	expectedProblemAttributes.put("ReferenceToForwardField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
Lines 1391-1396 Link Here
1391	expectedProblemAttributes.put("NonGenericConstructor", SKIP);	1399	expectedProblemAttributes.put("NonGenericConstructor", SKIP);
1392	expectedProblemAttributes.put("NonGenericMethod", SKIP);	1400	expectedProblemAttributes.put("NonGenericMethod", SKIP);
1393	expectedProblemAttributes.put("NonGenericType", SKIP);	1401	expectedProblemAttributes.put("NonGenericType", SKIP);
		1402	expectedProblemAttributes.put("NonNullFieldComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1394	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1403	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1395	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER));	1404	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER));
1396	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER));	1405	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(JavaCore.COMPILER_PB_STATIC_ACCESS_RECEIVER));
Lines 1403-1408 Link Here
1403	expectedProblemAttributes.put("NotVisibleField", SKIP);	1412	expectedProblemAttributes.put("NotVisibleField", SKIP);
1404	expectedProblemAttributes.put("NotVisibleMethod", SKIP);	1413	expectedProblemAttributes.put("NotVisibleMethod", SKIP);
1405	expectedProblemAttributes.put("NotVisibleType", SKIP);	1414	expectedProblemAttributes.put("NotVisibleType", SKIP);
		1415	expectedProblemAttributes.put("NullFieldComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		1416	expectedProblemAttributes.put("NullFieldInstanceofYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		1417	expectedProblemAttributes.put("NullFieldReference", new ProblemAttributes(JavaCore.COMPILER_PB_NULL_REFERENCE));
1406	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1418	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1407	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1419	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1408	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_NULL_REFERENCE));	1420	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_NULL_REFERENCE));
Lines 1444-1449 Link Here
1444	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(JavaCore.COMPILER_PB_UNCHECKED_TYPE_OPERATION));	1456	expectedProblemAttributes.put("PotentialHeapPollutionFromVararg", new ProblemAttributes(JavaCore.COMPILER_PB_UNCHECKED_TYPE_OPERATION));
1445	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE));	1457	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE));
1446	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE));	1458	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIALLY_UNCLOSED_CLOSEABLE));
		1459	expectedProblemAttributes.put("PotentialNullFieldReference", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE));
1447	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE));	1460	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(JavaCore.COMPILER_PB_POTENTIAL_NULL_REFERENCE));
1448	expectedProblemAttributes.put("PublicClassMustMatchFileName", SKIP);	1461	expectedProblemAttributes.put("PublicClassMustMatchFileName", SKIP);
1449	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", SKIP);	1462	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", SKIP);
Lines 1452-1459 Link Here
1452	expectedProblemAttributes.put("RedefinedArgument", SKIP);	1465	expectedProblemAttributes.put("RedefinedArgument", SKIP);
1453	expectedProblemAttributes.put("RedefinedLocal", SKIP);	1466	expectedProblemAttributes.put("RedefinedLocal", SKIP);
1454	expectedProblemAttributes.put("RedundantSpecificationOfTypeArguments", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS));	1467	expectedProblemAttributes.put("RedundantSpecificationOfTypeArguments", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_TYPE_ARGUMENTS));
		1468	expectedProblemAttributes.put("RedundantFieldNullAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1455	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1469	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		1470	expectedProblemAttributes.put("RedundantNullCheckOnNonNullField", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1456	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1471	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
		1472	expectedProblemAttributes.put("RedundantNullCheckOnNullField", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1457	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));	1473	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_NULL_CHECK));
1458	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_SUPERINTERFACE));	1474	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(JavaCore.COMPILER_PB_REDUNDANT_SUPERINTERFACE));
1459	expectedProblemAttributes.put("ReferenceToForwardField", SKIP);	1475	expectedProblemAttributes.put("ReferenceToForwardField", SKIP);

Lines 41-54 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java (-8 / +18 lines)
41	// record setting a variable: various scenarii are possible, setting an array reference,	41	// record setting a variable: various scenarii are possible, setting an array reference,
42	// a field reference, a blank final field reference, a field of an enclosing instance or	42	// a field reference, a blank final field reference, a field of an enclosing instance or
43	// just a local variable.	43	// just a local variable.
44	LocalVariableBinding local = this.lhs.localVariableBinding();	44	VariableBinding var = this.lhs.variableBinding();
45	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	45	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
46	this.expression.checkNPE(currentScope, flowContext, flowInfo);	46	this.expression.checkNPE(currentScope, flowContext, flowInfo);
47	}	47	}
48	flowInfo = ((Reference) this.lhs)	48	flowInfo = ((Reference) this.lhs)
49	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)	49	.analyseAssignment(currentScope, flowContext, flowInfo, this, false)
50	.unconditionalInits();	50	.unconditionalInits();
51	if (local != null) {	51	if (var instanceof LocalVariableBinding) {
		52	LocalVariableBinding local = (LocalVariableBinding) var;
52	LocalVariableBinding previousTrackerBinding = null;	53	LocalVariableBinding previousTrackerBinding = null;
53	if (local.closeTracker != null) {	54	if (local.closeTracker != null) {
54	// Assigning to a variable already holding an AutoCloseable, has it been closed before?	55	// Assigning to a variable already holding an AutoCloseable, has it been closed before?
Lines 59-75 Link Here
59	FakedTrackingVariable.handleResourceAssignment(flowInfo, this, this.expression, local, previousTrackerBinding);	60	FakedTrackingVariable.handleResourceAssignment(flowInfo, this, this.expression, local, previousTrackerBinding);
60	}	61	}
61	int nullStatus = this.expression.nullStatus(flowInfo);	62	int nullStatus = this.expression.nullStatus(flowInfo);
62	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	63	if (var != null && (var.type.tagBits & TagBits.IsBaseType) == 0) {
63	if (nullStatus == FlowInfo.NULL) {	64	if (nullStatus == FlowInfo.NULL) {
64	flowContext.recordUsingNullReference(currentScope, local, this.lhs,	65	flowContext.recordUsingNullReference(currentScope, var, this.lhs,
65	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_ASSIGNMENT, flowInfo);	66	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_ASSIGNMENT, flowInfo);
66	}	67	}
67	}	68	}
68	nullStatus = checkAgainstNullAnnotation(currentScope, local, nullStatus);	69	nullStatus = checkAgainstNullAnnotation(currentScope, var, nullStatus);
69	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	70	if (var != null && (var.type.tagBits & TagBits.IsBaseType) == 0) {
70	flowInfo.markNullStatus(local, nullStatus);	71	flowInfo.markNullStatus(var, nullStatus);
71	if (flowContext.initsOnFinally != null)	72	if (flowContext.initsOnFinally != null)
72	flowContext.initsOnFinally.markNullStatus(local, nullStatus);	73	flowContext.initsOnFinally.markNullStatus(var, nullStatus);
		74	if (var instanceof FieldBinding && var.isFinal() && ((FieldBinding) var).isStatic()) {
		75	// static final field being assigned. Record its null status for future reference
		76	// since the flowInfo from a constructor or static block wont be available in a method
		77	FieldBinding fieldBinding = (FieldBinding) var;
		78	fieldBinding.setNullStatusForStaticFinalField(nullStatus);
		79	}
73	}	80	}
74	return flowInfo;	81	return flowInfo;
75	}	82	}
Lines 223-226 Link Here
223	public LocalVariableBinding localVariableBinding() {	230	public LocalVariableBinding localVariableBinding() {
224	return this.lhs.localVariableBinding();	231	return this.lhs.localVariableBinding();
225	}	232	}
		233	public VariableBinding variableBinding() {
		234	return this.lhs.variableBinding();
		235	}
226	}	236	}

Lines 24-46 Link Here

(-)a/org.eclipse.jdt.core/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

(-)a/org.eclipse.jdt.core/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 564-570 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowContext.java (-14 / +14 lines)
564	* combined with a context indicator (one of {@link #IN_COMPARISON_NULL},	564	* combined with a context indicator (one of {@link #IN_COMPARISON_NULL},
565	* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})	565	* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})
566	*/	566	*/
567	protected void recordNullReference(LocalVariableBinding local,	567	protected void recordNullReference(VariableBinding local,
568	Expression expression, int status) {	568	Expression expression, int status) {
569	// default implementation: do nothing	569	// default implementation: do nothing
570	}	570	}
Lines 607-613 Link Here
607	* be known at the time of calling this method (they are influenced by	607	* be known at the time of calling this method (they are influenced by
608	* code that follows the current point)	608	* code that follows the current point)
609	*/	609	*/
610	public void recordUsingNullReference(Scope scope, LocalVariableBinding local,	610	public void recordUsingNullReference(Scope scope, VariableBinding local,
611	Expression reference, int checkType, FlowInfo flowInfo) {	611	Expression reference, int checkType, FlowInfo flowInfo) {
612	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 \|\|	612	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 \|\|
613	flowInfo.isDefinitelyUnknown(local)) {	613	flowInfo.isDefinitelyUnknown(local)) {
Lines 619-632 Link Here
619	if (flowInfo.isDefinitelyNonNull(local)) {	619	if (flowInfo.isDefinitelyNonNull(local)) {
620	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {	620	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {
621	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	621	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
622	scope.problemReporter().localVariableRedundantCheckOnNonNull(local, reference);	622	scope.problemReporter().variableRedundantCheckOnNonNull(local, reference);
623	}	623	}
624	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	624	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
625	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	625	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
626	}	626	}
627	} else {	627	} else {
628	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	628	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
629	scope.problemReporter().localVariableNonNullComparedToNull(local, reference);	629	scope.problemReporter().variableNonNullComparedToNull(local, reference);
630	}	630	}
631	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	631	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
632	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	632	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
Lines 646-656 Link Here
646	switch(checkType & CONTEXT_MASK) {	646	switch(checkType & CONTEXT_MASK) {
647	case FlowContext.IN_COMPARISON_NULL:	647	case FlowContext.IN_COMPARISON_NULL:
648	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	648	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
649	scope.problemReporter().localVariableNullReference(local, reference);	649	scope.problemReporter().variableNullReference(local, reference);
650	return;	650	return;
651	}	651	}
652	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	652	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
653	scope.problemReporter().localVariableRedundantCheckOnNull(local, reference);	653	scope.problemReporter().variableRedundantCheckOnNull(local, reference);
654	}	654	}
655	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	655	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
656	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	656	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
Lines 658-691 Link Here
658	return;	658	return;
659	case FlowContext.IN_COMPARISON_NON_NULL:	659	case FlowContext.IN_COMPARISON_NON_NULL:
660	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	660	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
661	scope.problemReporter().localVariableNullReference(local, reference);	661	scope.problemReporter().variableNullReference(local, reference);
662	return;	662	return;
663	}	663	}
664	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	664	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
665	scope.problemReporter().localVariableNullComparedToNonNull(local, reference);	665	scope.problemReporter().variableNullComparedToNonNull(local, reference);
666	}	666	}
667	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	667	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
668	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	668	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
669	}	669	}
670	return;	670	return;
671	case FlowContext.IN_ASSIGNMENT:	671	case FlowContext.IN_ASSIGNMENT:
672	scope.problemReporter().localVariableRedundantNullAssignment(local, reference);	672	scope.problemReporter().variableRedundantNullAssignment(local, reference);
673	return;	673	return;
674	case FlowContext.IN_INSTANCEOF:	674	case FlowContext.IN_INSTANCEOF:
675	scope.problemReporter().localVariableNullInstanceof(local, reference);	675	scope.problemReporter().variableNullInstanceof(local, reference);
676	return;	676	return;
677	}	677	}
678	} else if (flowInfo.isPotentiallyNull(local)) {	678	} else if (flowInfo.isPotentiallyNull(local)) {
679	switch(checkType & CONTEXT_MASK) {	679	switch(checkType & CONTEXT_MASK) {
680	case FlowContext.IN_COMPARISON_NULL:	680	case FlowContext.IN_COMPARISON_NULL:
681	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	681	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
682	scope.problemReporter().localVariablePotentialNullReference(local, reference);	682	scope.problemReporter().variablePotentialNullReference(local, reference);
683	return;	683	return;
684	}	684	}
685	break;	685	break;
686	case FlowContext.IN_COMPARISON_NON_NULL:	686	case FlowContext.IN_COMPARISON_NON_NULL:
687	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	687	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
688	scope.problemReporter().localVariablePotentialNullReference(local, reference);	688	scope.problemReporter().variablePotentialNullReference(local, reference);
689	return;	689	return;
690	}	690	}
691	break;	691	break;
Lines 696-706 Link Here
696	break;	696	break;
697	case MAY_NULL :	697	case MAY_NULL :
698	if (flowInfo.isDefinitelyNull(local)) {	698	if (flowInfo.isDefinitelyNull(local)) {
699	scope.problemReporter().localVariableNullReference(local, reference);	699	scope.problemReporter().variableNullReference(local, reference);
700	return;	700	return;
701	}	701	}
702	if (flowInfo.isPotentiallyNull(local)) {	702	if (flowInfo.isPotentiallyNull(local)) {
703	scope.problemReporter().localVariablePotentialNullReference(local, reference);	703	scope.problemReporter().variablePotentialNullReference(local, reference);
704	return;	704	return;
705	}	705	}
706	break;	706	break;

Lines 11-17 Link Here

(-)a/org.eclipse.jdt.core/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$