Attachment #206570 for bug #247564




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

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	}




			scope.problemReporter().messageSendRedundantCheckOnNonNull(rightMessage.binding, rightMessage);
		}

		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 114-119 Link Here

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




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




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




### 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 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 34-42 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/NullReferenceImplTests.java (-6 / +26 lines)
34	import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo;	34	import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo;
35	import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo.AssertionFailedException;	35	import org.eclipse.jdt.internal.compiler.flow.UnconditionalFlowInfo.AssertionFailedException;
36	import org.eclipse.jdt.internal.compiler.impl.Constant;	36	import org.eclipse.jdt.internal.compiler.impl.Constant;
		37	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
37	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;	38	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
38	import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;	39	import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
39	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	40	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
		41	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
40		42
41	/**	43	/**
42	* A tests series especially meant to validate the internals of our null	44	* A tests series especially meant to validate the internals of our null
Lines 1083-1100 Link Here
1083	return copy;	1085	return copy;
1084	}	1086	}
1085		1087
1086	public void markAsDefinitelyNonNull(LocalVariableBinding local) {	1088	public void markAsDefinitelyNonNull(VariableBinding local) {
1087	grow(local.id + this.maxFieldCount);	1089	int position;
		1090	if (local instanceof FieldBinding) {
		1091	position = local.id;
		1092	} else {
		1093	position = local.id + this.maxFieldCount;
		1094	}
		1095	grow(position);
1088	super.markAsDefinitelyNonNull(local);	1096	super.markAsDefinitelyNonNull(local);
1089	}	1097	}
1090		1098
1091	public void markAsDefinitelyNull(LocalVariableBinding local) {	1099	public void markAsDefinitelyNull(VariableBinding local) {
1092	grow(local.id + this.maxFieldCount);	1100	int position;
		1101	if (local instanceof FieldBinding) {
		1102	position = local.id;
		1103	} else {
		1104	position = local.id + this.maxFieldCount;
		1105	}
		1106	grow(position);
1093	super.markAsDefinitelyNull(local);	1107	super.markAsDefinitelyNull(local);
1094	}	1108	}
1095		1109
1096	public void markAsDefinitelyUnknown(LocalVariableBinding local) {	1110	public void markAsDefinitelyUnknown(VariableBinding local) {
1097	grow(local.id + this.maxFieldCount);	1111	int position;
		1112	if (local instanceof FieldBinding) {
		1113	position = local.id;
		1114	} else {
		1115	position = local.id + this.maxFieldCount;
		1116	}
		1117	grow(position);
1098	super.markAsDefinitelyUnknown(local);	1118	super.markAsDefinitelyUnknown(local);
1099	}	1119	}
1100		1120

Lines 39-61 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java (-4 / +4 lines)
39	scope.problemReporter().messageSendRedundantCheckOnNonNull(rightMessage.binding, rightMessage);	39	scope.problemReporter().messageSendRedundantCheckOnNonNull(rightMessage.binding, rightMessage);
40	}	40	}
41		41
42	LocalVariableBinding local = this.left.localVariableBinding();	42	VariableBinding local = this.left.variableBinding();
43	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	43	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
44	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.right.nullStatus(flowInfo), this.left);	44	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.right.nullStatus(flowInfo), this.left);
45	}	45	}
46	local = this.right.localVariableBinding();	46	local = this.right.variableBinding();
47	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	47	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
48	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.left.nullStatus(flowInfo), this.right);	48	checkVariableComparison(scope, flowContext, flowInfo, initsWhenTrue, initsWhenFalse, local, this.left.nullStatus(flowInfo), this.right);
49	}	49	}
50	}	50	}
51	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, LocalVariableBinding local, int nullStatus, Expression reference) {	51	private void checkVariableComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse, VariableBinding local, int nullStatus, Expression reference) {
52	switch (nullStatus) {	52	switch (nullStatus) {
53	case FlowInfo.NULL :	53	case FlowInfo.NULL :
54	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {	54	if (((this.bits & OperatorMASK) >> OperatorSHIFT) == EQUAL_EQUAL) {
55	flowContext.recordUsingNullReference(scope, local, reference,	55	flowContext.recordUsingNullReference(scope, local, reference,
56	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);	56	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NULL, flowInfo);
57	initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set	57	initsWhenTrue.markAsComparedEqualToNull(local); // from thereon it is set
58	initsWhenFalse.markAsComparedEqualToNonNull(local); // from thereon it is set	58	initsWhenFalse.markAsComparedEqualToNonNull(local ); // from thereon it is set
59	} else {	59	} else {
60	flowContext.recordUsingNullReference(scope, local, reference,	60	flowContext.recordUsingNullReference(scope, local, reference,
61	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);	61	FlowContext.CAN_ONLY_NULL_NON_NULL \| FlowContext.IN_COMPARISON_NON_NULL, flowInfo);

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 585-591 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowContext.java (-14 / +14 lines)
585	* combined with a context indicator (one of {@link #IN_COMPARISON_NULL},	585	* combined with a context indicator (one of {@link #IN_COMPARISON_NULL},
586	* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})	586	* {@link #IN_COMPARISON_NON_NULL}, {@link #IN_ASSIGNMENT} or {@link #IN_INSTANCEOF})
587	*/	587	*/
588	protected void recordNullReference(LocalVariableBinding local,	588	protected void recordNullReference(VariableBinding local,
589	Expression expression, int status) {	589	Expression expression, int status) {
590	// default implementation: do nothing	590	// default implementation: do nothing
591	}	591	}
Lines 628-634 Link Here
628	* be known at the time of calling this method (they are influenced by	628	* be known at the time of calling this method (they are influenced by
629	* code that follows the current point)	629	* code that follows the current point)
630	*/	630	*/
631	public void recordUsingNullReference(Scope scope, LocalVariableBinding local,	631	public void recordUsingNullReference(Scope scope, VariableBinding local,
632	Expression reference, int checkType, FlowInfo flowInfo) {	632	Expression reference, int checkType, FlowInfo flowInfo) {
633	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 \|\|	633	if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) != 0 \|\|
634	flowInfo.isDefinitelyUnknown(local)) {	634	flowInfo.isDefinitelyUnknown(local)) {
Lines 640-653 Link Here
640	if (flowInfo.isDefinitelyNonNull(local)) {	640	if (flowInfo.isDefinitelyNonNull(local)) {
641	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {	641	if (checkType == (CAN_ONLY_NULL_NON_NULL \| IN_COMPARISON_NON_NULL)) {
642	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	642	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
643	scope.problemReporter().localVariableRedundantCheckOnNonNull(local, reference);	643	scope.problemReporter().variableRedundantCheckOnNonNull(local, reference);
644	}	644	}
645	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	645	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
646	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	646	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
647	}	647	}
648	} else {	648	} else {
649	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	649	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
650	scope.problemReporter().localVariableNonNullComparedToNull(local, reference);	650	scope.problemReporter().variableNonNullComparedToNull(local, reference);
651	}	651	}
652	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	652	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
653	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	653	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
Lines 667-677 Link Here
667	switch(checkType & CONTEXT_MASK) {	667	switch(checkType & CONTEXT_MASK) {
668	case FlowContext.IN_COMPARISON_NULL:	668	case FlowContext.IN_COMPARISON_NULL:
669	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	669	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
670	scope.problemReporter().localVariableNullReference(local, reference);	670	scope.problemReporter().variableNullReference(local, reference);
671	return;	671	return;
672	}	672	}
673	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	673	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
674	scope.problemReporter().localVariableRedundantCheckOnNull(local, reference);	674	scope.problemReporter().variableRedundantCheckOnNull(local, reference);
675	}	675	}
676	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	676	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
677	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	677	flowInfo.initsWhenFalse().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
Lines 679-712 Link Here
679	return;	679	return;
680	case FlowContext.IN_COMPARISON_NON_NULL:	680	case FlowContext.IN_COMPARISON_NON_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().localVariableNullReference(local, reference);	682	scope.problemReporter().variableNullReference(local, reference);
683	return;	683	return;
684	}	684	}
685	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {	685	if ((this.tagBits & FlowContext.HIDE_NULL_COMPARISON_WARNING) == 0) {
686	scope.problemReporter().localVariableNullComparedToNonNull(local, reference);	686	scope.problemReporter().variableNullComparedToNonNull(local, reference);
687	}	687	}
688	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {	688	if (!flowInfo.isMarkedAsNullOrNonNullInAssertExpression(local)) {
689	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);	689	flowInfo.initsWhenTrue().setReachMode(FlowInfo.UNREACHABLE_BY_NULLANALYSIS);
690	}	690	}
691	return;	691	return;
692	case FlowContext.IN_ASSIGNMENT:	692	case FlowContext.IN_ASSIGNMENT:
693	scope.problemReporter().localVariableRedundantNullAssignment(local, reference);	693	scope.problemReporter().variableRedundantNullAssignment(local, reference);
694	return;	694	return;
695	case FlowContext.IN_INSTANCEOF:	695	case FlowContext.IN_INSTANCEOF:
696	scope.problemReporter().localVariableNullInstanceof(local, reference);	696	scope.problemReporter().variableNullInstanceof(local, reference);
697	return;	697	return;
698	}	698	}
699	} else if (flowInfo.isPotentiallyNull(local)) {	699	} else if (flowInfo.isPotentiallyNull(local)) {
700	switch(checkType & CONTEXT_MASK) {	700	switch(checkType & CONTEXT_MASK) {
701	case FlowContext.IN_COMPARISON_NULL:	701	case FlowContext.IN_COMPARISON_NULL:
702	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	702	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
703	scope.problemReporter().localVariablePotentialNullReference(local, reference);	703	scope.problemReporter().variablePotentialNullReference(local, reference);
704	return;	704	return;
705	}	705	}
706	break;	706	break;
707	case FlowContext.IN_COMPARISON_NON_NULL:	707	case FlowContext.IN_COMPARISON_NON_NULL:
708	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning	708	if (((checkType & CHECK_MASK) == CAN_ONLY_NULL) && (reference.implicitConversion & TypeIds.UNBOXING) != 0) { // check for auto-unboxing first and report appropriate warning
709	scope.problemReporter().localVariablePotentialNullReference(local, reference);	709	scope.problemReporter().variablePotentialNullReference(local, reference);
710	return;	710	return;
711	}	711	}
712	break;	712	break;
Lines 717-727 Link Here
717	break;	717	break;
718	case MAY_NULL :	718	case MAY_NULL :
719	if (flowInfo.isDefinitelyNull(local)) {	719	if (flowInfo.isDefinitelyNull(local)) {
720	scope.problemReporter().localVariableNullReference(local, reference);	720	scope.problemReporter().variableNullReference(local, reference);
721	return;	721	return;
722	}	722	}
723	if (flowInfo.isPotentiallyNull(local)) {	723	if (flowInfo.isPotentiallyNull(local)) {
724	scope.problemReporter().localVariablePotentialNullReference(local, reference);	724	scope.problemReporter().variablePotentialNullReference(local, reference);
725	return;	725	return;
726	}	726	}
727	break;	727	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$