Attachment #206525 for bug #186342

View | Details | Raw Unified | Return to bug 186342 | Differences between

and this patch

Lines 1799-1804 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java (+1 lines)
1799	" <argument value=\"---OUTPUT_DIR_PLACEHOLDER---\"/>\n" +	1799	" <argument value=\"---OUTPUT_DIR_PLACEHOLDER---\"/>\n" +
1800	" </command_line>\n" +	1800	" </command_line>\n" +
1801	" <options>\n" +	1801	" <options>\n" +
		1802	" <option key=\"org.eclipse.jdt.core.compiler.annotation.nullanalysis\" value=\"disabled\"/>\n" +
1802	" <option key=\"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode\" value=\"disabled\"/>\n" +	1803	" <option key=\"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode\" value=\"disabled\"/>\n" +
1803	" <option key=\"org.eclipse.jdt.core.compiler.codegen.targetPlatform\" value=\"1.5\"/>\n" +	1804	" <option key=\"org.eclipse.jdt.core.compiler.codegen.targetPlatform\" value=\"1.5\"/>\n" +
1804	" <option key=\"org.eclipse.jdt.core.compiler.codegen.unusedLocal\" value=\"optimize out\"/>\n" +	1805	" <option key=\"org.eclipse.jdt.core.compiler.codegen.unusedLocal\" value=\"optimize out\"/>\n" +




/*******************************************************************************
 * Copyright (c) 2010, 2011 GK Software AG and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Stephan Herrmann - initial API and implementation 
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;


import java.io.File;
import java.util.Map;

import junit.framework.Test;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

public class NullAnnotationTest extends AbstractComparableTest {

// class libraries including our default null annotation types:
String[] LIBS;

// names and content of custom annotations used in a few tests:
private static final String CUSTOM_NONNULL_NAME = "org/foo/NonNull.java";
private static final String CUSTOM_NONNULL_CONTENT = 
	"package org.foo;\n" +
	"import static java.lang.annotation.ElementType.*;\n" + 
	"import java.lang.annotation.*;\n" + 
	"@Retention(RetentionPolicy.CLASS)\n" + 
	"@Target({METHOD,PARAMETER,LOCAL_VARIABLE})\n" + 
	"public @interface NonNull {\n" + 
	"}\n";
private static final String CUSTOM_NULLABLE_NAME = "org/foo/Nullable.java";
private static final String CUSTOM_NULLABLE_CONTENT = "package org.foo;\n" +
	"import static java.lang.annotation.ElementType.*;\n" + 
	"import java.lang.annotation.*;\n" +
	"@Retention(RetentionPolicy.CLASS)\n" + 
	"@Target({METHOD,PARAMETER,LOCAL_VARIABLE})\n" + 
	"public @interface Nullable {\n" + 
	"}\n";

public NullAnnotationTest(String name) {
	super(name);
}

// Static initializer to specify tests subset using TESTS_* static variables
// All specified tests which do not belong to the class are skipped...
static {
//		TESTS_NAMES = new String[] { "test_nonnull_var_in_constrol_structure_3" };
//		TESTS_NUMBERS = new int[] { 561 };
//		TESTS_RANGE = new int[] { 1, 2049 };
}

public static Test suite() {
	return buildComparableTestSuite(testClass());
}

public static Class testClass() {
	return NullAnnotationTest.class;
}

protected void setUp() throws Exception {
	super.setUp();
	if (this.LIBS == null) {
		String[] defaultLibs = getDefaultClassPaths();
		int len = defaultLibs.length;
		this.LIBS = new String[len+1];
		System.arraycopy(defaultLibs, 0, this.LIBS, 0, len);
		File bundleFile = FileLocator.getBundleFile(Platform.getBundle("org.eclipse.jdt.annotation.null"));
		if (bundleFile.isDirectory())
			this.LIBS[len] = bundleFile.getPath()+"/bin";
		else
			this.LIBS[len] = bundleFile.getPath();
	}
}
// Conditionally augment problem detection settings
static boolean setNullRelatedOptions = true;
protected Map getCompilerOptions() {
    Map defaultOptions = super.getCompilerOptions();
    if (setNullRelatedOptions) {
    	defaultOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	    defaultOptions.put(CompilerOptions.OPTION_ReportPotentialNullReference, CompilerOptions.ERROR);
	    defaultOptions.put(CompilerOptions.OPTION_ReportRedundantNullCheck, CompilerOptions.ERROR);
		defaultOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE);
		defaultOptions.put(CompilerOptions.OPTION_IncludeNullInfoFromAsserts, CompilerOptions.ENABLED);
		
		defaultOptions.put(CompilerOptions.OPTION_ReportMissingOverrideAnnotationForInterfaceMethodImplementation, CompilerOptions.DISABLED);

		// enable null annotations:
		defaultOptions.put(CompilerOptions.OPTION_AnnotationBasedNullAnalysis, CompilerOptions.ENABLED);
		// leave other new options at these defaults:
//		defaultOptions.put(CompilerOptions.OPTION_ReportNullContractViolation, CompilerOptions.ERROR);
//		defaultOptions.put(CompilerOptions.OPTION_ReportPotentialNullContractViolation, CompilerOptions.ERROR);
//		defaultOptions.put(CompilerOptions.OPTION_ReportNullContractInsufficientInfo, CompilerOptions.WARNING);
		
//		defaultOptions.put(CompilerOptions.OPTION_NullableAnnotationName, "org.eclipse.jdt.annotation.Nullable");
//		defaultOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "org.eclipse.jdt.annotation.NonNull");
    }
    return defaultOptions;
}
void runNegativeTestWithLibs(String[] testFiles, String expectedErrorLog) {
	runNegativeTest(
			testFiles,
			expectedErrorLog,
			this.LIBS,
			false /*shouldFlush*/);
}
void runNegativeTestWithLibs(boolean shouldFlushOutputDirectory, String[] testFiles, Map customOptions, String expectedErrorLog) {
	runNegativeTest(
			shouldFlushOutputDirectory,
			testFiles,
			this.LIBS,
			customOptions,
			expectedErrorLog,
			// runtime options
		    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
void runNegativeTestWithLibs(String[] testFiles, Map customOptions, String expectedErrorLog) {
	runNegativeTestWithLibs(false /* flush output directory */,	testFiles, customOptions, expectedErrorLog);
}
void runConformTestWithLibs(String[] testFiles, Map customOptions, String expectedCompilerLog) {
	runConformTestWithLibs(false /* flush output directory */, testFiles, customOptions, expectedCompilerLog);
}
void runConformTestWithLibs(boolean shouldFlushOutputDirectory, String[] testFiles, Map customOptions, String expectedCompilerLog) {
	runConformTest(
			shouldFlushOutputDirectory,
			testFiles,
			this.LIBS,
			customOptions,
			expectedCompilerLog,
			"",/* expected output */
			"",/* expected error */
		    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
void runConformTest(String[] testFiles, Map customOptions, String expectedOutputString) {
	runConformTest(
			testFiles, 
			expectedOutputString, 
			null /*classLibraries*/, 
			true /*shouldFlushOutputDirectory*/,
			null /*vmArguments*/, 
			customOptions, 
			null /*customRequestor*/);
	
}
// a nullable argument is dereferenced without a check
public void test_nullable_paramter_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(@Nullable Object o) {\n" +
			  "        System.out.print(o.toString());\n" +
			  "    }\n" +
			  "}\n"},
	    "----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	System.out.print(o.toString());\n" + 
		"	                 ^\n" + 
		"Potential null pointer access: The variable o may be null at this location\n" + 
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}

// a null value is passed to a nullable argument
public void test_nullable_paramter_002() {
	runConformTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(@Nullable Object o) {\n" +
			  "        // nop\n" +
			  "    }\n" +
			  "    void bar() {\n" +
			  "        foo(null);\n" +
			  "    }\n" +
			  "}\n"},
	    "",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/);
}

// a non-null argument is checked for null
public void test_nonnull_parameter_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(@NonNull Object o) {\n" +
			  "        if (o != null)\n" +
			  "              System.out.print(o.toString());\n" +
			  "    }\n" +
			  "}\n"},
	    "----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	if (o != null)\n" + 
		"	    ^\n" + 
		"Redundant null check: The variable o cannot be null at this location\n" + 
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}
// a non-null argument is dereferenced without a check
public void test_nonnull_parameter_002() {
	runConformTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(@NonNull Object o) {\n" +
			  "        System.out.print(o.toString());\n" +
			  "    }\n" +
			  "    public static void main(String... args) {\n" +
			  "        new X().foo(\"OK\");\n" +
			  "    }\n" +
			  "}\n"},
	    "OK",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/);
}
// passing null to nonnull parameter - many fields in enclosing class
public void test_nonnull_parameter_003() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    int i00, i01, i02, i03, i04, i05, i06, i07, i08, i09;" +
			  "    int i10, i11, i12, i13, i14, i15, i16, i17, i18, i19;" +
			  "    int i20, i21, i22, i23, i24, i25, i26, i27, i28, i29;" +
			  "    int i30, i31, i32, i33, i34, i35, i36, i37, i38, i39;" +
			  "    int i40, i41, i42, i43, i44, i45, i46, i47, i48, i49;" +
			  "    int i50, i51, i52, i53, i54, i55, i56, i57, i58, i59;" +
			  "    int i60, i61, i62, i63, i64, i65, i66, i67, i68, i69;" +
			  "    void foo(@NonNull Object o) {\n" +
			  "        System.out.print(o.toString());\n" +
			  "    }\n" +
			  "    void bar() {\n" +
			  "        foo(null);\n" +
			  "    }\n" +
			  "}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	foo(null);\n" + 
		"	    ^^^^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}
// passing potential null to nonnull parameter - target method is consumed from .class
public void test_nonnull_parameter_004() {
	runConformTestWithLibs(
			new String[] {
				"Lib.java",
					"import org.eclipse.jdt.annotation.*;\n" +
				"public class Lib {\n" +
				"    void setObject(@NonNull Object o) { }\n" +
				"}\n"
			},
			null /*customOptions*/,
			"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			  "public class X {\n" +
			  "    void bar(Lib l, boolean b) {\n" +
			  "        Object o = null;\n" +
			  "        if (b) o = new Object();\n" +
			  "        l.setObject(o);\n" +
			  "    }\n" +
			  "}\n"},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	l.setObject(o);\n" + 
		"	            ^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value can be null\n" + 
		"----------\n");
}
// passing unknown value to nonnull parameter  - target method is consumed from .class
public void test_nonnull_parameter_005() {
	runConformTestWithLibs(
			new String[] {
				"Lib.java",
				"import org.eclipse.jdt.annotation.*;\n" +
				"public class Lib {\n" +
				"    void setObject(@NonNull Object o) { }\n" +
				"}\n"
			},
			null /*customOptions*/,
			"");
	runConformTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			  "public class X {\n" +
			  "    void bar(Lib l, Object o) {\n" +
			  "        l.setObject(o);\n" +
			  "    }\n" +
			  "}\n"},
		null /* options */,
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	l.setObject(o);\n" + 
		"	            ^\n" + 
		"Potential type mismatch: required \'@NonNull Object\' but nullness of the provided value is unknown\n" + 
		"----------\n");
}
// a ternary non-null expression is passed to a nonnull parameter
public void test_nonnull_parameter_006() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    	void m1(@NonNull String a) {}\n" + 
			  "		void m2(@Nullable String b) {\n" + 
			  "			m1(b == null ? \"\" : b);\n" + 
			  "		}\n" +
			  "}\n"},
		customOptions,
		""  /* compiler output */);
}
// nullable value passed to a non-null parameter in a super-call
public void test_nonnull_parameter_007() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"XSub.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class XSub extends XSuper {\n" +
			  "    	XSub(@Nullable String b) {\n" + 
			  "			super(b);\n" + 
			  "		}\n" +
			  "}\n",
			"XSuper.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class XSuper {\n" +
			  "    	XSuper(@NonNull String b) {\n" + 
			  "		}\n" +
			  "}\n"
		},		
		customOptions,
		"----------\n" + 
		"1. ERROR in XSub.java (at line 4)\n" + 
		"	super(b);\n" + 
		"	      ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n");
}
// a nullable value is passed to a non-null parameter in an allocation expression
public void test_nonnull_parameter_008() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    	X(@NonNull String a) {}\n" + 
			  "		static X create(@Nullable String b) {\n" + 
			  "			return new X(b);\n" + 
			  "		}\n" +
			  "}\n"},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return new X(b);\n" + 
		"	             ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n"  /* compiler output */);
}
// a nullable value is passed to a non-null parameter in a qualified allocation expression
public void test_nonnull_parameter_009() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    class Local {\n" +
			  "    	   Local(@NonNull String a) {}\n" +
			  "    }\n" + 
			  "	   Local create(@Nullable String b) {\n" + 
			  "	       return this.new Local(b);\n" + 
			  "    }\n" +
			  "}\n"},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	return this.new Local(b);\n" + 
		"	                      ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n"  /* compiler output */);
}
// assigning potential null to a nonnull local variable
public void test_nonnull_local_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "import org.eclipse.jdt.annotation.*;\n" +
			  "public class X {\n" +
			  "    void foo(boolean b, Object p) {\n" +
			  "        @NonNull Object o1 = b ? null : new Object();\n" +
			  "        @NonNull String o2 = \"\";\n" +
			  "        o2 = null;\n" +
			  "        @NonNull Object o3 = p;\n" +
			  "    }\n" +
			  "}\n"},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	@NonNull Object o1 = b ? null : new Object();\n" + 
		"	                     ^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value can be null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	o2 = null;\n" + 
		"	     ^^^^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 7)\n" + 
		"	@NonNull Object o3 = p;\n" + 
		"	                     ^\n" + 
		"Potential type mismatch: required \'@NonNull Object\' but nullness of the provided value is unknown\n" + 
		"----------\n",
		this.LIBS,
		true /* shouldFlush*/);
}

// a method tries to tighten the type specification, super declares parameter o as @Nullable
// other parameters: s is redefined from not constrained to @Nullable which is OK
//                   third is redefined from not constrained to @NonNull which is bad, too
public void test_parameter_specification_inheritance_001() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    void foo(String s, @Nullable Object o, Object third) { }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    void foo(@Nullable String s, @NonNull Object o, @NonNull Object third) { System.out.print(o.toString()); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	void foo(@Nullable String s, @NonNull Object o, @NonNull Object third) { System.out.print(o.toString()); }\n" + 
		"	                             ^^^^^^^^^^^^^^^\n" + 
		"Illegal redefinition of parameter o, inherited method from Lib declares this parameter as @Nullable\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 4)\n" + 
		"	void foo(@Nullable String s, @NonNull Object o, @NonNull Object third) { System.out.print(o.toString()); }\n" + 
		"	                                                ^^^^^^^^^^^^^^^\n" + 
		"Illegal redefinition of parameter third, inherited method from Lib does not constrain this parameter\n" + 
		"----------\n");
}
// a method body fails to redeclare the inherited null annotation, super declares parameter as @Nullable
public void test_parameter_specification_inheritance_002() {
	runConformTest(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    void foo(@Nullable Object o) { }\n" +
			"}\n"
		},
		"",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/);
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    void foo(Object o) {\n" +
			"        System.out.print(o.toString());\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	void foo(Object o) {\n" + 
		"	         ^^^^^^\n" + 
		"Missing null annotation: inherited method from Lib declares this parameter as @Nullable\n" + 
		"----------\n");
}
// a method relaxes the parameter null specification, super interface declares parameter o as @NonNull
// other (first) parameter just repeats the inherited @NonNull
public void test_parameter_specification_inheritance_003() {
	runConformTest(
		new String[] {
			"IX.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IX {\n" +
			"    void foo(@NonNull String s, @NonNull Object o);\n" +
			"}\n",
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X implements IX {\n" +
			"    public void foo(@NonNull String s, @Nullable Object o) { ; }\n" +
			"    void bar() { foo(\"OK\", null); }\n" +
			"}\n"
		},
		"",
	    this.LIBS,
	    false/*shouldFlush*/,
	    null/*vmArgs*/);
}
// a method adds a @NonNull annotation, super interface has no null annotation
// changing other from unconstrained to @Nullable is OK
public void test_parameter_specification_inheritance_004() {
	runConformTest(
		new String[] {
			"IX.java",
			"public interface IX {\n" +
			"    void foo(Object o, Object other);\n" +
			"}\n"
		});
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X implements IX {\n" +
			"    public void foo(@NonNull Object o, @Nullable Object other) { System.out.print(o.toString()); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	public void foo(@NonNull Object o, @Nullable Object other) { System.out.print(o.toString()); }\n" + 
		"	                ^^^^^^^^^^^^^^^\n" + 
		"Illegal redefinition of parameter o, inherited method from IX does not constrain this parameter\n" + 
		"----------\n");
}
// a method tries to relax the null contract, super declares @NonNull return
public void test_parameter_specification_inheritance_005() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, //dont' flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	@Nullable Object getObject() { return null; }\n" + 
		"	^^^^^^^^^^^^^^^^\n" + 
		"The return type is incompatible with the @NonNull return from Lib.getObject()\n" + 
		"----------\n");
}

// super has no constraint for return, sub method confirms the null contract as @Nullable 
public void test_parameter_specification_inheritance_006() {
	runConformTest(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    Object getObject() { return null; }\n" +
			"}\n"
		});
	runConformTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}
// a method body violates the inherited null specification, super declares @NonNull return, missing redeclaration
public void test_parameter_specification_inheritance_007() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	Object getObject() { return null; }\n" + 
		"	^^^^^^\n" + 
		"The return type is incompatible with the @NonNull return from Lib.getObject()\n" + 
		"----------\n");
}
//a method body violates the @NonNull return specification (repeated from super)
public void test_parameter_specification_inheritance_007a() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    @NonNull Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	@NonNull Object getObject() { return null; }\n" + 
		"	                                     ^^^^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// a client potentially violates the inherited null specification, super interface declares @NonNull parameter
public void test_parameter_specification_inheritance_008() {
	Map options = getCompilerOptions();
	options.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
			"IX.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IX {\n" +
			"    void printObject(@NonNull Object o);\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X implements IX {\n" +
			"    public void printObject(Object o) { System.out.print(o.toString()); }\n" +
			"}\n",
			"M.java",
			"public class M{\n" +
			"    void foo(IX x, Object o) {\n" +
			"        x.printObject(o);\n" +
			"    }\n" +
			"}\n"
		},
		options,
		"----------\n" + 
		// additional error:
		"1. ERROR in X.java (at line 2)\n" + 
		"	public void printObject(Object o) { System.out.print(o.toString()); }\n" + 
		"	                        ^^^^^^\n" + 
		"Missing null annotation: inherited method from IX declares this parameter as @NonNull\n" + 
		"----------\n" +
		// main error:
		"----------\n" + 
		"1. ERROR in M.java (at line 3)\n" + 
		"	x.printObject(o);\n" + 
		"	              ^\n" + 
		"Potential type mismatch: required \'@NonNull Object\' but nullness of the provided value is unknown\n" + 
		"----------\n");
}
// a static method has a more relaxed null contract than a like method in the super class, but no overriding.
public void test_parameter_specification_inheritance_009() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull static Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X extends Lib {\n" +
			"    @Nullable static Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
}
// class default is nonnull, method and its super both use the default
public void test_parameter_specification_inheritance_010() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected String getString(String s) {\n" +
			"        if (Character.isLowerCase(s.charAt(0)))\n" +
			"	        return getString(s);\n" +
			"	     return s;\n" +
			"    }\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y extends X {\n" +
			"    @Override\n" +
			"    protected String getString(String s) {\n" +
			"	     return super.getString(s);\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		"");
}
// class default is nonnull, method and its super both use the default, super-call passes null
public void test_parameter_specification_inheritance_011() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected String getString(String s) {\n" +
			"        if (Character.isLowerCase(s.charAt(0)))\n" +
			"	        return getString(s);\n" +
			"	     return s;\n" +
			"    }\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y extends X {\n" +
			"    @Override\n" +
			"    protected String getString(String s) {\n" +
			"	     return super.getString(null);\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p1\\Y.java (at line 7)\n" + 
		"	return super.getString(null);\n" + 
		"	                       ^^^^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value is null\n" + 
		"----------\n");
}
// methods from two super types have different null contracts.
// sub-class merges both using the weakest common contract 
public void test_parameter_specification_inheritance_012() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    public @Nullable String getString(String s1, @Nullable String s2, @NonNull String s3) {\n" +
			"	     return s1;\n" +
			"    }\n" +
			"}\n",
	"p1/IY.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IY {\n" +
			"    @NonNull String getString(@NonNull String s1, @NonNull String s2, @Nullable String s3);\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends X implements IY {\n" +
			"    @Override\n" +
			"    public @NonNull String getString(@Nullable String s1, @Nullable String s2, @Nullable String s3) {\n" +
			"	     return \"\";\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		"");
}
// methods from two super types have different null contracts.
// sub-class overrides this method in non-conforming ways 
public void test_parameter_specification_inheritance_013() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    public @Nullable String getString(String s1, @Nullable String s2, @NonNull String s3) {\n" +
			"	     return s1;\n" +
			"    }\n" +
			"}\n",
	"p1/IY.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IY {\n" +
			"    @NonNull String getString(@NonNull String s1, @NonNull String s2, @Nullable String s3);\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends X implements IY {\n" +
			"    @Override\n" +
			"    public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" +
			"	     return \"\";\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p1\\Y.java (at line 5)\n" + 
		"	public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" + 
		"	       ^^^^^^^^^^^^^^^^\n" + 
		"The return type is incompatible with the @NonNull return from IY.getString(String, String, String)\n" + 
		"----------\n" + 
		"2. ERROR in p1\\Y.java (at line 5)\n" + 
		"	public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" + 
		"	                                  ^^^^^^\n" + 
		"Missing null annotation: inherited method from IY declares this parameter as @NonNull\n" + 
		"----------\n" + 
		"3. ERROR in p1\\Y.java (at line 5)\n" + 
		"	public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" + 
		"	                                             ^^^^^^^^^^^^^^^\n" + 
		"Illegal redefinition of parameter s2, inherited method from X declares this parameter as @Nullable\n" + 
		"----------\n" + 
		"4. ERROR in p1\\Y.java (at line 5)\n" + 
		"	public @Nullable String getString(String s1, @NonNull String s2, @NonNull String s3) {\n" + 
		"	                                                                 ^^^^^^^^^^^^^^^\n" + 
		"Illegal redefinition of parameter s3, inherited method from IY declares this parameter as @Nullable\n" + 
		"----------\n");
}
// methods from two super types have different null contracts.
// sub-class does not override, but should to bridge the incompatibility
public void test_parameter_specification_inheritance_014() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/IY.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public interface IY {\n" +
			"    public @NonNull String getString1(String s);\n" +
			"    public @NonNull String getString2(String s);\n" +
			"    public String getString3(@Nullable String s);\n" +
			"    public @NonNull String getString4(@Nullable String s);\n" +
			"    public @NonNull String getString5(@Nullable String s);\n" +
			"    public @Nullable String getString6(@NonNull String s);\n" +
			"}\n",
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    public @Nullable String getString1(String s) {\n" + // incomp. return
			"	     return s;\n" +
			"    }\n" +
			"    public String getString2(String s) {\n" +			 // incomp. return
			"	     return s;\n" +
			"    }\n" +
			"    public String getString3(String s) {\n" +			 // incomp. arg
			"	     return \"\";\n" +
			"    }\n" +
			"    public @NonNull String getString4(@Nullable String s) {\n" +
			"	     return \"\";\n" +
			"    }\n" +
			"    public @NonNull String getString5(@NonNull String s) {\n" + // incomp. arg
			"	     return s;\n" +
			"    }\n" +
			"    public @NonNull String getString6(@Nullable String s) {\n" +
			"	     return \"\";\n" +
			"    }\n" +
			"}\n",
	"p1/Y.java",
			"package p1;\n" +
			"public class Y extends X implements IY {\n" +
			"}\n",
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p1\\Y.java (at line 2)\n" + 
		"	public class Y extends X implements IY {\n" + 
		"	             ^\n" + 
		"The method getString1(String) from class X cannot implement the corresponding method from type IY due to incompatible nullness constraints\n" + 
		"----------\n" + 
		"2. ERROR in p1\\Y.java (at line 2)\n" + 
		"	public class Y extends X implements IY {\n" + 
		"	             ^\n" + 
		"The method getString2(String) from class X cannot implement the corresponding method from type IY due to incompatible nullness constraints\n" + 
		"----------\n" + 
		"3. ERROR in p1\\Y.java (at line 2)\n" + 
		"	public class Y extends X implements IY {\n" + 
		"	             ^\n" + 
		"The method getString5(String) from class X cannot implement the corresponding method from type IY due to incompatible nullness constraints\n" + 
		"----------\n" + 
		"4. ERROR in p1\\Y.java (at line 2)\n" + 
		"	public class Y extends X implements IY {\n" + 
		"	             ^\n" + 
		"The method getString3(String) from class X cannot implement the corresponding method from type IY due to incompatible nullness constraints\n" + 
		"----------\n");
}
// a nullable return value is dereferenced without a check
public void test_nullable_return_001() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"    void foo() {\n" +
			"        Object o = getObject();\n" +
			"        System.out.print(o.toString());\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 6)\n" + 
		"	System.out.print(o.toString());\n" + 
		"	                 ^\n" + 
		"Potential null pointer access: The variable o may be null at this location\n" + 
		"----------\n");
}
// a nullable return value is dereferenced without a check, method is read from .class file
public void test_nullable_return_002() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X {\n" +
			"    void foo(Lib l) {\n" +
			"        Object o = l.getObject();\n" +
			"        System.out.print(o.toString());\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	System.out.print(o.toString());\n" + 
		"	                 ^\n" + 
		"Potential null pointer access: The variable o may be null at this location\n" + 
		"----------\n");
}
// a non-null return value is checked for null, method is read from .class file
public void test_nonnull_return_001() {
	runConformTestWithLibs(
		new String[] {
			"Lib.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"");
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
			"X.java",
			"public class X {\n" +
			"    void foo(Lib l) {\n" +
			"        Object o = l.getObject();\n" +
			"        if (o != null)\n" +
			"            System.out.print(o.toString());\n" +
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	if (o != null)\n" + 
		"	    ^\n" + 
		"Redundant null check: The variable o cannot be null at this location\n" + 
		"----------\n");
}
// a non-null method returns null
public void test_nonnull_return_003() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(boolean b) {\n" +
			"        if (b)\n" +
			"            return null;\n" + // definite specification violation despite enclosing "if"
			"        return new Object();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return null;\n" + 
		"	       ^^^^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// a non-null method potentially returns null
public void test_nonnull_return_004() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(@Nullable Object o) {\n" +
			"        return o;\n" + // 'o' is only potentially null
			"    }\n" +
			"}\n"
		},
		null /*customOptions*/,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	return o;\n" + 
		"	       ^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value can be null\n" + 
		"----------\n");
}
// a non-null method returns its non-null argument
public void test_nonnull_return_005() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(@NonNull Object o) {\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}
//a non-null method has insufficient nullness info for its return value
public void test_nonnull_return_006() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(Object o) {\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\n" + 
		"	return o;\n" + 
		"	       ^\n" + 
		"Potential type mismatch: required \'@NonNull Object\' but nullness of the provided value is unknown\n" + 
		"----------\n");
}
// a result from a nullable method is directly dereferenced
public void test_nonnull_return_007() {
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object getObject() {\n" +
			"        return null;\n" +
			"    }\n" +
			"    void test() {\n" +
			"        getObject().toString();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	getObject().toString();\n" + 
		"	^^^^^^^^^^^\n" + 
		"Potential null pointer access: The method getObject() may return null\n" + 
		"----------\n");
}
// a result from a nonnull method is directly checked for null: redundant
public void test_nonnull_return_008() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportRedundantNullCheck, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject() {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"    void test() {\n" +
			"        if (getObject() == null)\n" +
			"		     throw new RuntimeException();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	if (getObject() == null)\n" + 
		"	    ^^^^^^^^^^^\n" + 
		"Redundant null check: The method getObject() cannot return null\n" + 
		"----------\n");
}
// a result from a nonnull method is directly checked for null (from local): redundant
public void test_nonnull_return_009() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportRedundantNullCheck, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject() {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"    void test() {\n" +
			"        Object left = null;\n" +
			"        if (left != getObject())\n" +
			"		     throw new RuntimeException();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 8)\n" + 
		"	if (left != getObject())\n" + 
		"	    ^^^^\n" + 
		"Redundant null check: The variable left can only be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	if (left != getObject())\n" + 
		"	            ^^^^^^^^^^^\n" + 
		"Redundant null check: The method getObject() cannot return null\n" + 
		"----------\n");
}
// a result from a nullable method is assigned and checked for null (from local): not redundant
// see also Bug 336428 - [compiler][null] bogus warning "redundant null check" in condition of do {} while() loop
public void test_nonnull_return_010() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportRedundantNullCheck, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable X getX() {\n" +
			"        return new X();\n" +
			"    }\n" +
			"    void test() {\n" +
			"        X left = this;\n" +
			"        do {\n" +
			"            if (left == null) \n" +
			"	   	         throw new RuntimeException();\n" +
			"        } while ((left = left.getX()) != null);\n" + // no warning/error here!
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 9)\n" + 
		"	if (left == null) \n" + 
		"	    ^^^^\n" + 
		"Null comparison always yields false: The variable left cannot be null at this location\n" + 
		"----------\n");
}
// a non-null method returns a checked-for null value, but that branch is dead code
public void test_nonnull_return_011() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    Object getObject(Object dubious) {\n" +
			"        if (dubious == null)\n" + // redundant
			"            return dubious;\n" + // definitely null, but not reported inside dead code
			"        return new Object();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	if (dubious == null)\n" + 
		"	    ^^^^^^^\n" + 
		"Null comparison always yields false: The variable dubious cannot be null at this location\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 6)\n" + 
		"	return dubious;\n" + 
		"	^^^^^^^^^^^^^^^\n" + 
		"Dead code\n" + 
		"----------\n");
}
// a non-null method returns a definite null from a conditional expression
// requires the fix for Bug 354554 - [null] conditional with redundant condition yields weak error message
// TODO(SH): ENABLE!
public void _test_nonnull_return_012() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    Object getObject(Object dubious) {\n" +
			"        return dubious == null ? dubious : null;\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	return dubious == null ? dubious : null;\n" + 
		"	       ^^^^^^^\n" + 
		"Null comparison always yields false: The variable dubious cannot be null at this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 5)\n" + 
		"	return dubious == null ? dubious : null;\n" + 
		"	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// don't apply any default annotations to return void
public void test_nonnull_return_013() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    void getObject() {}\n" +
			"}\n",
			"Y.java",
			"public class Y extends X {\n" +
			"    @Override\n" +
			"    void getObject() {}\n" + // don't complain, void takes no (default) annotation
			"}\n"
		},
		customOptions,
		"");
}
//suppress an error regarding null-spec violation
public void test_suppress_001() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_SuppressOptionalErrors, CompilerOptions.ENABLED);
	runConformTestWithLibs(
			new String[] {
				"X.java",
				"import org.eclipse.jdt.annotation.*;\n" +
				"public class X {\n" +
				"    @SuppressWarnings(\"null\")\n" +
				"    @NonNull Object getObject(@Nullable Object o) {\n" +
				"        return o;\n" + // 'o' is only potentially null
				"    }\n" +
				"}\n"
			},
			customOptions,
			"");	
}
// mixed use of fully qualified name / explicit import
public void test_annotation_import_001() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NullableAnnotationName, "org.foo.Nullable");
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "org.foo.NonNull");
	runConformTestWithLibs(
		new String[] {
			CUSTOM_NULLABLE_NAME,
			CUSTOM_NULLABLE_CONTENT,
			CUSTOM_NONNULL_NAME,
			CUSTOM_NONNULL_CONTENT,
			"Lib.java",
			"public class Lib {\n" +
			"    @org.foo.NonNull Object getObject() { return new Object(); }\n" + 	// FQN
			"}\n",
			"X.java",
			"import org.foo.NonNull;\n" +											// explicit import
			"public class X {\n" +
			"    @NonNull Object getObject(@NonNull Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}

// use of explicit imports throughout
public void test_annotation_import_002() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NullableAnnotationName, "org.foo.Nullable");
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "org.foo.NonNull");
	runConformTest(
		new String[] {
			CUSTOM_NULLABLE_NAME,
			CUSTOM_NULLABLE_CONTENT,
			CUSTOM_NONNULL_NAME,
			CUSTOM_NONNULL_CONTENT,
			"Lib.java",
			"import org.foo.NonNull;\n" +
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"import org.foo.NonNull;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(@org.foo.Nullable String dummy, @NonNull Lib l) {\n" +
			"        Object o = l.getObject();" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}
// explicit import of existing annotation types
// using a Lib without null specifications
public void test_annotation_import_005() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NullableAnnotationName, "org.foo.MayBeNull");
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "org.foo.MustNotBeNull");
	runNegativeTest(
		true/*shouldFlushOutputDirectory*/,
		new String[] {
			"org/foo/MayBeNull.java",
			"package org.foo;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" +
			"public @interface MayBeNull {}\n",
			
			"org/foo/MustNotBeNull.java",
			"package org.foo;\n" +
			"import java.lang.annotation.*;\n" +
			"@Retention(RetentionPolicy.CLASS)\n" +
			"public @interface MustNotBeNull {}\n",

			"Lib.java",
			"public class Lib {\n" +
			"    Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"import org.foo.*;\n" +
			"public class X {\n" +
			"    @MustNotBeNull Object getObject(@MustNotBeNull Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n",
			
		},
		null /*no libs*/,
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	return l.getObject();\n" + 
		"	       ^^^^^^^^^^^^^\n" + 
		"Potential type mismatch: required \'@MustNotBeNull Object\' but nullness of the provided value is unknown\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a non-null method returns a value obtained from an unannotated method, missing annotation types
public void test_annotation_import_006() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NullableAnnotationName, "org.foo.MayBeNull");
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "org.foo.MustNotBeNull");
	runNegativeTest(
		true/*shouldFlushOutputDirectory*/,
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"public class X {\n" +
			"    @MustNotBeNull Object getObject(@MustNotBeNull Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n"
		},
		null /* no libs */,
		customOptions,
		"----------\n" +
		"1. ERROR in X.java (at line 2)\n" + 
		"	@MustNotBeNull Object getObject(@MustNotBeNull Lib l) {\n" + 
		"	 ^^^^^^^^^^^^^\n" + 
		"MustNotBeNull cannot be resolved to a type\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 2)\n" + 
		"	@MustNotBeNull Object getObject(@MustNotBeNull Lib l) {\n" + 
		"	                                 ^^^^^^^^^^^^^\n" + 
		"MustNotBeNull cannot be resolved to a type\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// using nullness defaulting to nonnull, missing annotation types
public void test_annotation_import_007() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportNullSpecInsufficientInfo, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NullableAnnotationName, "org.foo.MayBeNull");
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "org.foo.MustNotBeNull");
	customOptions.put(CompilerOptions.OPTION_NonNullIsDefault, CompilerOptions.ENABLED);
	runNegativeTest(
		true/*shouldFlushOutputDirectory*/,
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"public class X {\n" +
			"    Object getObject(Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n"
		},
		this.LIBS,
		customOptions,
		"----------\n" + 
		"1. ERROR in Lib.java (at line 1)\n" + 
		"	public class Lib {\n" + 
		"	^\n" + 
		"Buildpath problem: the type org.foo.MustNotBeNull which is configured as a null annotation type cannot be resolved\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// a null annotation is illegally used on a class:
public void test_illegal_annotation_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNull public class X {\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	@NonNull public class X {\n" + 
		"	^^^^^^^^\n" + 
		"The annotation @NonNull is disallowed for this location\n" + 
		"----------\n",
		this.LIBS,
		false/*shouldFlush*/);
}
// this test has been removed:
// setting default to nullable, default applies to a parameter
// public void test_default_nullness_001()

// a null annotation is illegally defined by its simple name
public void test_illegal_annotation_002() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "NichtNull");
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"public class X {\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 0)\n" + 
		"	public class X {\n" + 
		"	^\n" + 
		"Cannot use the unqualified name \'NichtNull\' as an annotation name for null specification\n" + 
		"----------\n");
}
public void test_default_nullness_002() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NonNullIsDefault, CompilerOptions.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    Object getObject(@Nullable Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
			"Y.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends X {\n" +
			"    @Override\n" +
			"    @Nullable Object getObject(Object o) {\n" + // complain illegal return redef and inherited annot is not repeated
			"        return o;\n" +
			"    }\n" +
			"}\n",
		},
		customOptions,
		// main error:
		"----------\n" + 
		"1. ERROR in Y.java (at line 4)\n" + 
		"	@Nullable Object getObject(Object o) {\n" + 
		"	^^^^^^^^^^^^^^^^\n" + 
		"The return type is incompatible with the @NonNull return from X.getObject(Object)\n" + 
		"----------\n" +
		// additional error:
		"2. ERROR in Y.java (at line 4)\n" + 
		"	@Nullable Object getObject(Object o) {\n" + 
		"	                           ^^^^^^\n" + 
		"Illegal redefinition of parameter o, inherited method from X declares this parameter as @Nullable\n" + 
		"----------\n");
}
// package default is non-null
public void test_default_nullness_003() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected Object getObject(@Nullable Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
	"p2/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p2;\n",
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    protected @Nullable Object getObject(@Nullable Object o) {\n" +
			"        bar(o);\n" +
			"        return o;\n" +
			"    }\n" +
			"	 void bar(Object o2) { }\n" + // parameter is nonnull per package default
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p2\\Y.java (at line 5)\n" + 
		"	protected @Nullable Object getObject(@Nullable Object o) {\n" + 
		"	          ^^^^^^^^^^^^^^^^\n" + 
		"The return type is incompatible with the @NonNull return from X.getObject(Object)\n" + 
		"----------\n" + 
		"2. ERROR in p2\\Y.java (at line 6)\n" + 
		"	bar(o);\n" + 
		"	    ^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value can be null\n" + 
		"----------\n");
}
// package level default is consumed from package-info.class
public void test_default_nullness_003a() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected Object getObject(@Nullable Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"	 protected void bar(Object o2) { }\n" + // parameter is nonnull per type default
			"}\n",
	"p2/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p2;\n",
			},
			customOptions,
			"");
	// check if default is visible from package-info.class.
	runNegativeTestWithLibs(
		false, // don't flush
		new String[] {
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    protected @Nullable Object getObject(@Nullable Object o) {\n" + // can't override inherited default nonnull 
			"        bar(o);\n" + // parameter is nonnull in super class's .class file
			"        accept(o);\n" +
			"        return o;\n" +
			"    }\n" +
			"    void accept(Object a) {}\n" + // governed by package level default
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p2\\Y.java (at line 5)\n" + 
		"	protected @Nullable Object getObject(@Nullable Object o) {\n" + 
		"	          ^^^^^^^^^^^^^^^^\n" + 
		"The return type is incompatible with the @NonNull return from X.getObject(Object)\n" + 
		"----------\n" + 
		"2. ERROR in p2\\Y.java (at line 6)\n" + 
		"	bar(o);\n" + 
		"	    ^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value can be null\n" + 
		"----------\n" + 
		"3. ERROR in p2\\Y.java (at line 7)\n" + 
		"	accept(o);\n" + 
		"	       ^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value can be null\n" + 
		"----------\n");
}
// don't apply type-level default to non-reference type
public void test_default_nullness_004() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    protected Object getObject(boolean o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    protected @NonNull Object getObject(boolean o) {\n" +
			"        return o ? this : new Object();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}
// package default is non-null
// see also Bug 354536 - compiling package-info.java still depends on the order of compilation units
public void test_default_nullness_005() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "org.foo.NonNull");
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    class Inner {" +
			"        protected Object getObject(String s) {\n" +
			"            return null;\n" +
			"        }\n" +
			"    }\n" +
			"}\n",
	"p1/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p1;\n",
	CUSTOM_NONNULL_NAME,
			CUSTOM_NONNULL_CONTENT
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p1\\X.java (at line 4)\n" + 
		"	return null;\n" + 
		"	       ^^^^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// package default is non-null, package-info.java read before the annotation type
// compile order: beginToCompile(X.Inner) triggers reading of package-info.java before the annotation type was read
public void test_default_nullness_006() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "org.foo.NonNull");
	runNegativeTestWithLibs(
		new String[] {
	"p1/package-info.java",
			"@org.eclipse.jdt.annotation.NonNullByDefault\n" +
			"package p1;\n",
	"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    class Inner {" +
			"        protected Object getObject(String s) {\n" +
			"            return null;\n" +
			"        }\n" +
			"    }\n" +
			"}\n",
	CUSTOM_NONNULL_NAME,
			CUSTOM_NONNULL_CONTENT
		},
		customOptions,
		"----------\n" + 
		"1. ERROR in p1\\X.java (at line 4)\n" + 
		"	return null;\n" + 
		"	       ^^^^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value is null\n" + 
		"----------\n");
}
// global default nonnull, but return may be null 
public void test_default_nullness_007() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NonNullIsDefault, CompilerOptions.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    @Nullable Object dangerous() {\n" +
			"        return null;\n" + 
			"    }\n" +
			"    Object broken() {\n" +
			"        return dangerous();\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	return dangerous();\n" + 
		"	       ^^^^^^^^^^^\n" + 
		"Type mismatch: required \'@NonNull Object\' but the provided value can be null\n" + 
		"----------\n");
}

// cancel type level default to comply with super specification
public void test_default_nullness_008() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    protected Object getObject(Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y extends p1.X {\n" +
			"    @Override\n" +
			"    @NonNullByDefault(false)\n" +
			"    protected Object getObject(Object o) {\n" +
			"        if (o.toString().length() == 0)\n" + // dereference without a warning
			"	        return null;\n" + // return null without a warning
			"        return o.toString();\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"");
}

// cancel outer type level default to comply with super specification
public void test_default_nullness_009() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	runNegativeTestWithLibs(
		new String[] {
	"p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"    protected Object getObject(Object o) {\n" +
			"        return new Object();\n" +
			"    }\n" +
			"}\n",
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y { \n" +
			"    @NonNullByDefault(false)\n" +
			"    static class Z extends p1.X {\n" +
			"        @Override\n" +
			"        protected Object getObject(Object o) {\n" +
			"            if (o.toString().length() == 0) {\n" +
			"                o = null;\n" + // assign null without a warning
			"                bar(o); // error: arg is declared @NonNull\n" +
			"	             return null;\n" +
			"            }\n" +
			"            return o.toString();\n" +
			"        }\n" +
			"        String bar(@NonNull Object o) {\n" +
			"            return getObject(o).toString();" +
			"        }\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" +
		"1. ERROR in p2\\Y.java (at line 11)\n" + 
		"	bar(o); // error: arg is declared @NonNull\n" +
		"	    ^\n" +
		"Type mismatch: required \'@NonNull Object\' but the provided value is null\n" +
		"----------\n");
}
// non-null declarations are redundant within a default scope.
public void test_default_nullness_010() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	runConformTestWithLibs(
		new String[] {
	"p2/Y.java",
			"package p2;\n" +
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class Y {\n" +
			"    protected @NonNull Object getObject(@NonNull Object o) {\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		customOptions,
		"----------\n" + 
		"1. WARNING in p2\\Y.java (at line 5)\n" + 
		"	protected @NonNull Object getObject(@NonNull Object o) {\n" + 
		"	          ^^^^^^^^^^^^^^^\n" + 
		"The nullness annotation is redundant with a default that applies to this location\n" + 
		"----------\n" + 
		"2. WARNING in p2\\Y.java (at line 5)\n" + 
		"	protected @NonNull Object getObject(@NonNull Object o) {\n" + 
		"	                                    ^^^^^^^^^^^^^^^^^\n" + 
		"The nullness annotation is redundant with a default that applies to this location\n" + 
		"----------\n");
}
// a nonnull variable is dereferenced in a loop
public void test_nonnull_var_in_constrol_structure_1() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NonNullIsDefault, CompilerOptions.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void print4(@NonNull String s) {\n" +
			"        for (int i=0; i<4; i++)\n" +
			"             print(s);\n" + 
			"    }\n" +
			"    void print5(@Nullable String s) {\n" +
			"        for (int i=0; i<5; i++)\n" +
			"             print(s);\n" + 
			"    }\n" +
			"    void print6(boolean b) {\n" +
			"        String s = b ? null : \"\";\n" +
			"        for (int i=0; i<5; i++)\n" +
			"             print(s);\n" + 
			"    }\n" +
			"    void print(@NonNull String s) {\n" +
			"        System.out.print(s);\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	void print4(@NonNull String s) {\n" + 
		"	            ^^^^^^^^^^^^^^^^^\n" + 
		"The nullness annotation is redundant with a default that applies to this location\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 9)\n" + 
		"	print(s);\n" + 
		"	      ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 14)\n" + 
		"	print(s);\n" + 
		"	      ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 16)\n" + 
		"	void print(@NonNull String s) {\n" + 
		"	           ^^^^^^^^^^^^^^^^^\n" + 
		"The nullness annotation is redundant with a default that applies to this location\n" + 
		"----------\n");
}
// a nonnull variable is dereferenced in a finally block
public void test_nonnull_var_in_constrol_structure_2() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NonNullIsDefault, CompilerOptions.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void print4(String s) {\n" +
			"        try { /*empty*/ } finally {\n" +
			"             print(s);\n" +
			"        }\n" + 
			"    }\n" +
			"    void print5(@Nullable String s) {\n" +
			"        try { /*empty*/ } finally {\n" +
			"             print(s);\n" +
			"        }\n" + 
			"    }\n" +
			"    void print6(boolean b) {\n" +
			"        String s = b ? null : \"\";\n" +
			"        try { /*empty*/ } finally {\n" +
			"             print(s);\n" +
			"        }\n" + 
			"    }\n" +
			"    void print(String s) {\n" +
			"        System.out.print(s);\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	print(s);\n" + 
		"	      ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 16)\n" + 
		"	print(s);\n" + 
		"	      ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n");
}
// a nonnull variable is dereferenced in a finally block inside a loop
public void test_nonnull_var_in_constrol_structure_3() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NonNullIsDefault, CompilerOptions.ENABLED);
	customOptions.put(CompilerOptions.OPTION_ReportRedundantNullAnnotation, CompilerOptions.IGNORE);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"public class X {\n" +
			"    void print4(@NonNull String s) {\n" +
			"        for (int i=0; i<4; i++)\n" +
			"            try { /*empty*/ } finally {\n" +
			"                 print(s);\n" +
			"            }\n" + 
			"    }\n" +
			"    void print5(@Nullable String s) {\n" +
			"        for (int i=0; i<5; i++)\n" +
			"            try { /*empty*/ } finally {\n" +
			"                 print(s);\n" +
			"            }\n" + 
			"    }\n" +
			"    void print6(boolean b) {\n" +
			"        String s = b ? null : \"\";\n" +
			"        for (int i=0; i<4; i++)\n" +
			"            try { /*empty*/ } finally {\n" +
			"                 print(s);\n" +
			"            }\n" + 
			"    }\n" +
			"    void print(@NonNull String s) {\n" +
			"        System.out.print(s);\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 12)\n" + 
		"	print(s);\n" + 
		"	      ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 19)\n" + 
		"	print(s);\n" + 
		"	      ^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n");
}
// a nonnull variable is dereferenced method of a nested type
public void test_nesting_1() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_ReportPotentialNullSpecViolation, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NonNullIsDefault, CompilerOptions.ENABLED);
	runNegativeTestWithLibs(
		new String[] {
			"X.java",
			"import org.eclipse.jdt.annotation.*;\n" +
			"@NonNullByDefault\n" +
			"public class X {\n" +
			"    void print4(final String s1) {\n" +
			"        for (int i=0; i<3; i++)\n" +
			"            new Runnable() {\n" +
			"                public void run() {\n" +
			"                     print(s1);\n" +
			"                }\n" +
			"            }.run();\n" + 
			"    }\n" +
			"    void print8(final @Nullable String s2) {\n" +
			"        for (int i=0; i<3; i++)\n" +
			"            new Runnable() {\n" +
			"                public void run() {\n" +
			"                     print(s2);\n" +
			"                }\n" +
			"            }.run();\n" + 
			"    }\n" +
			"    void print16(boolean b) {\n" +
			"        final String s3 = b ? null : \"\";\n" +
			"        for (int i=0; i<3; i++)\n" +
			"            new Runnable() {\n" +
			"                public void run() {\n" +
			"                     @NonNull String s3R = s3;\n" +
			"                }\n" +
			"            }.run();\n" + 
			"    }\n" +
			"    void print(String s) {\n" +
			"        System.out.print(s);\n" +
			"    }\n" +
			"}\n",

		},
		customOptions,
		"----------\n" + 
		"1. ERROR in X.java (at line 16)\n" + 
		"	print(s2);\n" + 
		"	      ^^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 25)\n" + 
		"	@NonNull String s3R = s3;\n" + 
		"	                      ^^\n" + 
		"Type mismatch: required \'@NonNull String\' but the provided value can be null\n" + 
		"----------\n");
}
// Test a regression incurred to the OT/J based implementation
// by the fix in Bug 360328 - [compiler][null] detect null problems in nested code (local class inside a loop)
public void test_constructor_with_nested_class() {
	runConformTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    final Object o1;\n" +
			"    final Object o2;\n" +
			"    public X() {\n" +
			"         this.o1 = new Object() {\n" +
			"             public String toString() { return \"O1\"; }\n" +
			"         };\n" +
			"         this.o2 = new Object();" +
			"    }\n" +
			"}\n"
		},
		"");
}
}

Lines 96-101 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/TestAll.java (+1 lines)
96	since_1_5.add(InnerEmulationTest_1_5.class);	96	since_1_5.add(InnerEmulationTest_1_5.class);
97	since_1_5.add(AssignmentTest_1_5.class);	97	since_1_5.add(AssignmentTest_1_5.class);
98	since_1_5.add(InnerClass15Test.class);	98	since_1_5.add(InnerClass15Test.class);
		99	since_1_5.add(NullAnnotationTest.class);
99		100
100	// Tests to run when compliance is greater than 1.5	101	// Tests to run when compliance is greater than 1.5
101	ArrayList since_1_6 = new ArrayList();	102	ArrayList since_1_6 = new ArrayList();




	/** @since 3.8 */
	int SwitchOnEnumNotBelow15 = TypeRelated + 890;	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=360317
	/**
	 * Errors/warnings from annotation based null analysis
	 */
	/** @since 3.8 */
	int RequiredNonNullButProvidedNull = TypeRelated + 910;
	/** @since 3.8 */
	int RequiredNonNullButProvidedPotentialNull = TypeRelated + 911;
	/** @since 3.8 */
	int RequiredNonNullButProvidedUnknown = TypeRelated + 912;
	/** @since 3.8 */
	int MissingNullAnnotationType = ImportRelated + 913;
	/** @since 3.8 */
	int NullAnnotationNameMustBeQualified = Internal + 914;
	/** @since 3.8 */
	int IllegalReturnNullityRedefinition = MethodRelated + 915;
	/** @since 3.8 */
	int IllegalRedefinitionToNonNullParameter = MethodRelated + 916;
	/** @since 3.8 */
	int IllegalDefinitionToNonNullParameter = MethodRelated + 917;
	/** @since 3.8 */
	int ParameterLackingNonNullAnnotation = MethodRelated + 918;
	/** @since 3.8 */
	int ParameterLackingNullableAnnotation = MethodRelated + 919;
	/** @since 3.8 */
	int PotentialNullMessageSendReference = Internal + 920;
	/** @since 3.8 */
	int RedundantNullCheckOnNonNullMessageSend = Internal + 921;
	/** @since 3.8 */
	int CannotImplementIncompatibleNullness = Internal + 922;
	/** @since 3.8 */
	int RedundantNullAnnotation = MethodRelated + 923;
	
	/**
	 * External problems -- These are problems defined by other plugins
	 */


Lines 254-259 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (+8 lines)
254	// this is only used for method invocation as the expression inside an expression statement	254	// this is only used for method invocation as the expression inside an expression statement
255	public static final int InsideExpressionStatement = Bit5;	255	public static final int InsideExpressionStatement = Bit5;
256		256
		257	// for annotation reference, signal if annotation was created from a default:
		258	public static final int IsSynthetic = ASTNode.Bit7;
		259	// for name reference within a memberValuePair of an annotation:
		260	public static final int IsMemberValueReference = ASTNode.Bit15;
		261
		262	// for method declaration to avoid duplicate invocation of bindArguments()
		263	public static final int HasBoundArguments = ASTNode.Bit10;
		264
257	public ASTNode() {	265	public ASTNode() {
258		266
259	super();	267	super();

Lines 10-17 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java (-1 / +62 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	11	package org.eclipse.jdt.internal.compiler.ast;
12		12
		13	import java.util.Arrays;
		14
13	import org.eclipse.jdt.core.compiler.*;	15	import org.eclipse.jdt.core.compiler.*;
14	import org.eclipse.jdt.internal.compiler.*;	16	import org.eclipse.jdt.internal.compiler.*;
		17	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
15	import org.eclipse.jdt.internal.compiler.impl.*;	18	import org.eclipse.jdt.internal.compiler.impl.*;
16	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	19	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
17	import org.eclipse.jdt.internal.compiler.codegen.*;	20	import org.eclipse.jdt.internal.compiler.codegen.*;
Lines 66-78 Link Here
66	throw new AbortMethod(this.compilationResult, problem);	69	throw new AbortMethod(this.compilationResult, problem);
67	}	70	}
68	}	71	}
		72
		73	/**
		74	* Materialize a null annotation that has been added from the current default,
		75	* in order to ensure that this annotation will be generated into the .class file, too.
		76	*/
		77	public void addNullnessAnnotation(ReferenceBinding annotationBinding) {
		78	this.annotations = addAnnotation(this, this.annotations, annotationBinding);
		79	}
		80
		81	/**
		82	* Materialize a null parameter annotation that has been added from the current default,
		83	* in order to ensure that this annotation will be generated into the .class file, too.
		84	*/
		85	public void addParameterNonNullAnnotation(int i, ReferenceBinding annotationBinding) {
		86	Argument argument = this.arguments[i];
		87	if (argument.type != null) // null happens for constructors of anonymous classes
		88	argument.annotations = addAnnotation(argument.type, argument.annotations, annotationBinding);
		89	}
		90
		91	private Annotation[] addAnnotation(ASTNode location, Annotation[] oldAnnotations, ReferenceBinding annotationBinding) {
		92	long pos = ((long)location.sourceStart<<32) + location.sourceEnd;
		93	long[] poss = new long[annotationBinding.compoundName.length];
		94	Arrays.fill(poss, pos);
		95	MarkerAnnotation annotation = new MarkerAnnotation(new QualifiedTypeReference(annotationBinding.compoundName, poss), location.sourceStart);
		96	annotation.declarationSourceEnd = location.sourceEnd;
		97	annotation.resolvedType = annotationBinding;
		98	annotation.bits = IsSynthetic;
		99	if (oldAnnotations == null) {
		100	oldAnnotations = new Annotation[] {annotation};
		101	} else {
		102	int len = oldAnnotations.length;
		103	System.arraycopy(oldAnnotations, 0, oldAnnotations=new Annotation[len+1], 1, len);
		104	oldAnnotations[0] = annotation;
		105	}
		106	return oldAnnotations;
		107	}
69		108
70	/**	109	/**
71	* Bind and add argument's binding into the scope of the method	110	* Bind and add argument's binding into the scope of the method
72	*/	111	*/
73	public void bindArguments() {	112	public void bindArguments() {
74		113
75	if (this.arguments != null) {	114	if (this.arguments != null && (this.bits & HasBoundArguments) == 0) {
		115	this.bits \|= HasBoundArguments;
76	// by default arguments in abstract/native methods are considered to be used (no complaint is expected)	116	// by default arguments in abstract/native methods are considered to be used (no complaint is expected)
77	if (this.binding == null) {	117	if (this.binding == null) {
78	for (int i = 0, length = this.arguments.length; i < length; i++) {	118	for (int i = 0, length = this.arguments.length; i < length; i++) {
Lines 85-90 Link Here
85	for (int i = 0, length = this.arguments.length; i < length; i++) {	125	for (int i = 0, length = this.arguments.length; i < length; i++) {
86	Argument argument = this.arguments[i];	126	Argument argument = this.arguments[i];
87	argument.bind(this.scope, this.binding.parameters[i], used);	127	argument.bind(this.scope, this.binding.parameters[i], used);
		128	// argument.bind() has resolved annotations, now transfer nullness info from the argument to the method:
		129	if ((argument.binding.tagBits & (TagBits.AnnotationNonNull\|TagBits.AnnotationNullable)) != 0) {
		130	if (this.binding.parameterNonNullness == null)
		131	this.binding.parameterNonNullness = new Boolean[this.arguments.length];
		132	this.binding.parameterNonNullness[i] = Boolean.valueOf((argument.binding.tagBits & TagBits.AnnotationNonNull) != 0);
		133	}
88	if (argument.annotations != null) {	134	if (argument.annotations != null) {
89	if (paramAnnotations == null) {	135	if (paramAnnotations == null) {
90	paramAnnotations = new AnnotationBinding[length][];	136	paramAnnotations = new AnnotationBinding[length][];
Lines 143-148 Link Here
143	}	189	}
144	}	190	}
145		191
		192	void analyseArgumentNullity(FlowInfo info) {
		193	if (this.arguments != null && this.binding.parameterNonNullness != null) {
		194	for (int i = 0, count = this.arguments.length; i < count; i++) {
		195	// leverage null-info from parameter annotations:
		196	Boolean nonNullNess = this.binding.parameterNonNullness[i];
		197	if (nonNullNess != null) {
		198	if (nonNullNess.booleanValue())
		199	info.markAsDefinitelyNonNull(this.arguments[i].binding);
		200	else
		201	info.markPotentiallyNullBit(this.arguments[i].binding);
		202	}
		203	}
		204	}
		205	}
		206
146	public CompilationResult compilationResult() {	207	public CompilationResult compilationResult() {
147		208
148	return this.compilationResult;	209	return this.compilationResult;

Lines 53-58 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (+1 lines)
53	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	53	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
54	}	54	}
55	}	55	}
		56	analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
56	}	57	}
57	// record some dependency information for exception types	58	// record some dependency information for exception types
58	ReferenceBinding[] thrownExceptions;	59	ReferenceBinding[] thrownExceptions;




			case TypeIds.T_JavaxAnnotationPreDestroy :
				tagBits |= TagBits.AnnotationPreDestroy;
				break;
			case TypeIds.T_ConfiguredAnnotationNullable :
				tagBits |= TagBits.AnnotationNullable;
				break;
			case TypeIds.T_ConfiguredAnnotationNonNull :
				tagBits |= TagBits.AnnotationNonNull;
				break;
			case TypeIds.T_ConfiguredAnnotationNonNullByDefault :
				if (valueAttribute != null 
					&& valueAttribute.value instanceof FalseLiteral) 
				{
					// parameter 'false' means: this annotation cancels any defaults
					tagBits |= TagBits.AnnotationNullUnspecifiedByDefault;
					break;
				}
				tagBits |= TagBits.AnnotationNonNullByDefault;
				break;
		}
		return tagBits;
	}

Lines 65-71 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java (-1 / +1 lines)
65	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_ASSIGNMENT, flowInfo);	65	FlowContext.CAN_ONLY_NULL \| FlowContext.IN_ASSIGNMENT, flowInfo);
66	}	66	}
67	}	67	}
68	nullStatus = checkAgainstNullAnnotation(currentScope, local, nullStatus);	68	nullStatus = checkAssignmentAgainstNullAnnotation(currentScope, flowContext, local, nullStatus, this.expression);
69	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {	69	if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {
70	flowInfo.markNullStatus(local, nullStatus);	70	flowInfo.markNullStatus(local, nullStatus);
71	if (flowContext.initsOnFinally != null)	71	if (flowContext.initsOnFinally != null)




			}
		}

		// tag parameters as being set
		if (this.arguments != null) {
			for (int i = 0, count = this.arguments.length; i < count; i++) {
				if (this.binding.parameterNonNullness != null) {
					// leverage null-info from parameter annotations:
					Boolean nonNullNess = this.binding.parameterNonNullness[i];
					if (nonNullNess != null) {
						if (nonNullNess.booleanValue())
							flowInfo.markAsDefinitelyNonNull(this.arguments[i].binding);
						else
							flowInfo.markPotentiallyNullBit(this.arguments[i].binding);
					}
				}
				// tag parameters as being set
				flowInfo.markAsDefinitelyAssigned(this.arguments[i].binding);
			}
		}




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

		super(left,right,operator);
	}
	private void checkNullComparison(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo, FlowInfo initsWhenTrue, FlowInfo initsWhenFalse) {
		// check sends to null-annotated methods:
		MessageSend leftMessage = (this.left instanceof MessageSend) ? (MessageSend) this.left : null;
		if (   leftMessage != null 
			&& leftMessage.nullStatus(flowInfo) == FlowInfo.NON_NULL
			&& this.right.nullStatus(flowInfo) == FlowInfo.NULL) 
		{
			scope.problemReporter().messageSendRedundantCheckOnNonNull(leftMessage.binding, leftMessage);
		}
		MessageSend rightMessage = (this.right instanceof MessageSend) ? (MessageSend) this.right : null;
		if (   rightMessage != null 
			&& rightMessage.nullStatus(flowInfo) == FlowInfo.NON_NULL 
			&& this.left.nullStatus(flowInfo) == FlowInfo.NULL) 
		{
			scope.problemReporter().messageSendRedundantCheckOnNonNull(rightMessage.binding, rightMessage);
		}

		LocalVariableBinding local = this.left.localVariableBinding();
		if (local != null && (local.type.tagBits & TagBits.IsBaseType) == 0) {

Lines 81-86 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ExplicitConstructorCall.java (+1 lines)
81	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	81	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
82	}	82	}
83	}	83	}
		84	analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
84	}	85	}
85		86
86	ReferenceBinding[] thrownExceptions;	87	ReferenceBinding[] thrownExceptions;

Lines 85-91 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (-1 / +1 lines)
85	this.bits &= ~FirstAssignmentToLocal; // int i = (i = 0);	85	this.bits &= ~FirstAssignmentToLocal; // int i = (i = 0);
86	}	86	}
87	flowInfo.markAsDefinitelyAssigned(this.binding);	87	flowInfo.markAsDefinitelyAssigned(this.binding);
88	nullStatus = checkAgainstNullAnnotation(currentScope, this.binding, nullStatus);	88	nullStatus = checkAssignmentAgainstNullAnnotation(currentScope, flowContext, this.binding, nullStatus, this.initialization);
89	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {	89	if ((this.binding.type.tagBits & TagBits.IsBaseType) == 0) {
90	flowInfo.markNullStatus(this.binding, nullStatus);	90	flowInfo.markNullStatus(this.binding, nullStatus);
91	// no need to inform enclosing try block since its locals won't get	91	// no need to inform enclosing try block since its locals won't get

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MemberValuePair.java (-1 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2010 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 41-46 Link Here
41	if (value instanceof ArrayInitializer) {	41	if (value instanceof ArrayInitializer) {
42	value.bits \|= IsAnnotationDefaultValue;	42	value.bits \|= IsAnnotationDefaultValue;
43	}	43	}
		44	if (value instanceof NameReference) {
		45	value.bits \|= IsMemberValueReference;
		46	}
44	}	47	}
45		48
46	/* (non-Javadoc)	49	/* (non-Javadoc)

Lines 99-104 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-1 / +14 lines)
99	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);	99	flowInfo = FakedTrackingVariable.markPassedToOutside(currentScope, this.arguments[i], flowInfo);
100	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	100	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
101	}	101	}
		102	analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
102	}	103	}
103	ReferenceBinding[] thrownExceptions;	104	ReferenceBinding[] thrownExceptions;
104	if ((thrownExceptions = this.binding.thrownExceptions) != Binding.NO_EXCEPTIONS) {	105	if ((thrownExceptions = this.binding.thrownExceptions) != Binding.NO_EXCEPTIONS) {
Lines 114-119 Link Here
114	}	115	}
115	manageSyntheticAccessIfNecessary(currentScope, flowInfo);	116	manageSyntheticAccessIfNecessary(currentScope, flowInfo);
116	return flowInfo;	117	return flowInfo;
		118	}
		119	public void checkNPE(BlockScope scope, FlowContext flowContext, FlowInfo flowInfo) {
		120	super.checkNPE(scope, flowContext, flowInfo);
		121	if (nullStatus(flowInfo) == FlowInfo.POTENTIALLY_NULL)
		122	scope.problemReporter().messageSendPotentialNullReference(this.binding, this);
117	}	123	}
118	/**	124	/**
119	* @see org.eclipse.jdt.internal.compiler.ast.Expression#computeConversion(org.eclipse.jdt.internal.compiler.lookup.Scope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding, org.eclipse.jdt.internal.compiler.lookup.TypeBinding)	125	* @see org.eclipse.jdt.internal.compiler.ast.Expression#computeConversion(org.eclipse.jdt.internal.compiler.lookup.Scope, org.eclipse.jdt.internal.compiler.lookup.TypeBinding, org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
Lines 268-276 Link Here
268	}	274	}
269	}	275	}
270	public int nullStatus(FlowInfo flowInfo) {	276	public int nullStatus(FlowInfo flowInfo) {
		277	if (this.binding.isValidBinding()) {
		278	// try to retrieve null status of this message send from an annotation of the called method:
		279	long tagBits = this.binding.tagBits;
		280	if ((tagBits & TagBits.AnnotationNonNull) != 0)
		281	return FlowInfo.NON_NULL;
		282	if ((tagBits & TagBits.AnnotationNullable) != 0)
		283	return FlowInfo.POTENTIALLY_NULL;
		284	}
271	return FlowInfo.UNKNOWN;	285	return FlowInfo.UNKNOWN;
272	}	286	}
273
274	/**	287	/**
275	* @see org.eclipse.jdt.internal.compiler.ast.Expression#postConversionType(Scope)	288	* @see org.eclipse.jdt.internal.compiler.ast.Expression#postConversionType(Scope)
276	*/	289	*/




					this.scope,
					FlowInfo.DEAD_END);

			// tag parameters as being set
			if (this.arguments != null) {
				for (int i = 0, count = this.arguments.length; i < count; i++) {
					if (this.binding.parameterNonNullness != null) {
						// leverage null-info from parameter annotations:
						Boolean nonNullNess = this.binding.parameterNonNullness[i];
						if (nonNullNess != null) {
							if (nonNullNess.booleanValue())
								flowInfo.markAsDefinitelyNonNull(this.arguments[i].binding);
							else
								flowInfo.markPotentiallyNullBit(this.arguments[i].binding);
						}
					}
					// tag parameters as being set:
					flowInfo.markAsDefinitelyAssigned(this.arguments[i].binding);
					// if this method uses a type parameter declared by the declaring class,
					// it can't be static. https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682

Lines 86-91 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (+1 lines)
86	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	86	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
87	}	87	}
88	}	88	}
		89	analyseArguments(currentScope, flowContext, flowInfo, this.binding, this.arguments);
89	}	90	}
90		91
91	// analyse the anonymous nested type	92	// analyse the anonymous nested type

Lines 963-969 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-1 / +5 lines)
963	&& methodScope.lastVisibleFieldID >= 0	963	&& methodScope.lastVisibleFieldID >= 0
964	&& fieldBinding.id >= methodScope.lastVisibleFieldID	964	&& fieldBinding.id >= methodScope.lastVisibleFieldID
965	&& (!fieldBinding.isStatic() \|\| methodScope.isStatic)) {	965	&& (!fieldBinding.isStatic() \|\| methodScope.isStatic)) {
966	scope.problemReporter().forwardReference(this, this.indexOfFirstFieldBinding-1, fieldBinding);	966	if ((this.bits & IsMemberValueReference) != 0 && fieldBinding.id == methodScope.lastVisibleFieldID) {
		967	// false alarm, location is NOT a field initializer but the value in a memberValuePair
		968	} else {
		969	scope.problemReporter().forwardReference(this, this.indexOfFirstFieldBinding-1, fieldBinding);
		970	}
967	}	971	}
968	if (isFieldUseDeprecated(fieldBinding, scope, this.indexOfFirstFieldBinding == this.tokens.length ? this.bits : 0)) {	972	if (isFieldUseDeprecated(fieldBinding, scope, this.indexOfFirstFieldBinding == this.tokens.length ? this.bits : 0)) {
969	scope.problemReporter().deprecatedField(fieldBinding, this);	973	scope.problemReporter().deprecatedField(fieldBinding, this);

Lines 44-49 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (+19 lines)
44	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	44	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
45	this.expression.checkNPE(currentScope, flowContext, flowInfo);	45	this.expression.checkNPE(currentScope, flowContext, flowInfo);
46	}	46	}
		47	if (flowInfo.reachMode() == FlowInfo.REACHABLE)
		48	checkAgainstNullAnnotation(currentScope, this.expression.nullStatus(flowInfo));
47	FakedTrackingVariable trackingVariable = FakedTrackingVariable.getCloseTrackingVariable(this.expression);	49	FakedTrackingVariable trackingVariable = FakedTrackingVariable.getCloseTrackingVariable(this.expression);
48	if (trackingVariable != null) {	50	if (trackingVariable != null) {
49	if (methodScope != trackingVariable.methodScope)	51	if (methodScope != trackingVariable.methodScope)
Lines 119-124 Link Here
119	currentScope.checkUnclosedCloseables(flowInfo, this, currentScope);	121	currentScope.checkUnclosedCloseables(flowInfo, this, currentScope);
120	return FlowInfo.DEAD_END;	122	return FlowInfo.DEAD_END;
121	}	123	}
		124	void checkAgainstNullAnnotation(BlockScope scope, int nullStatus) {
		125	if (nullStatus != FlowInfo.NON_NULL) {
		126	// if we can't prove non-null check against declared null-ness of the enclosing method:
		127	long tagBits;
		128	MethodBinding methodBinding;
		129	try {
		130	methodBinding = scope.methodScope().referenceMethod().binding;
		131	tagBits = methodBinding.tagBits;
		132	} catch (NullPointerException npe) {
		133	return;
		134	}
		135	if ((tagBits & TagBits.AnnotationNonNull) != 0) {
		136	char[][] annotationName = scope.environment().getNonNullAnnotationName();
		137	scope.problemReporter().nullityMismatch(this.expression, methodBinding.returnType, nullStatus, annotationName);
		138	}
		139	}
		140	}
122		141
123	/**	142	/**
124	* Retrun statement code generation	143	* Retrun statement code generation




	public static final int COMPLAINED_FAKE_REACHABLE = 1;
	public static final int COMPLAINED_UNREACHABLE = 2;
	

/** Analysing arguments of MessageSend, ExplicitConstructorCall, AllocationExpression. */
protected void analyseArguments(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, MethodBinding methodBinding, Expression[] arguments) 
{
	// compare actual null-status against parameter annotations of the called method:
	if (arguments != null && methodBinding.parameterNonNullness != null) {
		for (int i = 0; i < arguments.length; i++) {
			if (methodBinding.parameterNonNullness[i] == Boolean.TRUE) { 
				TypeBinding expectedType = methodBinding.parameters[i];
				Expression argument = arguments[i];
				int nullStatus = argument.nullStatus(flowInfo); // slight loss of precision: should also use the null info from the receiver.
				if (nullStatus != FlowInfo.NON_NULL) // if required non-null is not provided
					flowContext.recordNullityMismatch(currentScope, argument, nullStatus, expectedType);
			}
		}
	}
}

/** Check null-ness of 'local' against a possible null annotation */
protected int checkAssignmentAgainstNullAnnotation(BlockScope currentScope, FlowContext flowContext,
												   LocalVariableBinding local, int nullStatus, Expression expression)
{
	if (   local != null
		&& (local.tagBits & TagBits.AnnotationNonNull) != 0 
		&& nullStatus != FlowInfo.NON_NULL)
	{
		flowContext.recordNullityMismatch(currentScope, expression, nullStatus, local.type);
		nullStatus=FlowInfo.NON_NULL;
	}
	return nullStatus;
}


Lines 17-22 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FinallyFlowContext.java (-2 / +25 lines)
17	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;	17	import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
18	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;	18	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
19	import org.eclipse.jdt.internal.compiler.lookup.Scope;	19	import org.eclipse.jdt.internal.compiler.lookup.Scope;
		20	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
20	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	21	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
21	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;	22	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
22		23
Lines 83-90 Link Here
83	// check inconsistent null checks	84	// check inconsistent null checks
84	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative	85	if ((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0) { // within an enclosing loop, be conservative
85	for (int i = 0; i < this.nullCount; i++) {	86	for (int i = 0; i < this.nullCount; i++) {
86	this.parent.recordUsingNullReference(scope, this.nullLocals[i],	87	if (this.nullCheckTypes[i] == ASSIGN_TO_NONNULL)
87	this.nullReferences[i], this.nullCheckTypes[i], flowInfo);	88	this.parent.recordNullityMismatch(scope, this.nullReferences[i],
		89	flowInfo.nullStatus(this.nullLocals[i]), this.expectedTypes[i]);
		90	else
		91	this.parent.recordUsingNullReference(scope, this.nullLocals[i],
		92	this.nullReferences[i], this.nullCheckTypes[i], flowInfo);
		93
88	}	94	}
89	}	95	}
90	else { // no enclosing loop, be as precise as possible right now	96	else { // no enclosing loop, be as precise as possible right now
Lines 165-170 Link Here
165	}	171	}
166	if (flowInfo.isPotentiallyNull(local)) {	172	if (flowInfo.isPotentiallyNull(local)) {
167	scope.problemReporter().localVariablePotentialNullReference(local, expression);	173	scope.problemReporter().localVariablePotentialNullReference(local, expression);
		174	}
		175	break;
		176	case ASSIGN_TO_NONNULL:
		177	int nullStatus = flowInfo.nullStatus(local);
		178	if (nullStatus != FlowInfo.NON_NULL) {
		179	char[][] annotationName = scope.environment().getNonNullAnnotationName();
		180	scope.problemReporter().nullityMismatch(expression, this.expectedTypes[i], nullStatus, annotationName);
168	}	181	}
169	break;	182	break;
170	default:	183	default:
Lines 442-445 Link Here
442	this.nullReferences[this.nullCount] = expression;	455	this.nullReferences[this.nullCount] = expression;
443	this.nullCheckTypes[this.nullCount++] = status;	456	this.nullCheckTypes[this.nullCount++] = status;
444	}	457	}
		458	protected boolean internalRecordNullityMismatch(Expression expression, int nullStatus, TypeBinding expectedType, int checkType) {
		459	// cf. decision structure inside FinallyFlowContext.recordUsingNullReference(..)
		460	if (nullStatus == FlowInfo.UNKNOWN \|\|
		461	((this.tagBits & FlowContext.DEFER_NULL_DIAGNOSTIC) != 0 && nullStatus != FlowInfo.NULL)) {
		462	recordExpectedType(expectedType, this.nullCount);
		463	recordNullReference(expression.localVariableBinding(), expression, checkType);
		464	return true;
		465	}
		466	return false;
		467	}
445	}	468	}

Lines 52-57 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/FlowContext.java (+48 lines)
52	// any null related operation happening within the try block	52	// any null related operation happening within the try block
53		53
54	public int tagBits;	54	public int tagBits;
		55
		56	// array to store the expected type from the potential error location (for display in error messages):
		57	public TypeBinding[] expectedTypes = null;
		58
55	public static final int DEFER_NULL_DIAGNOSTIC = 0x1;	59	public static final int DEFER_NULL_DIAGNOSTIC = 0x1;
56	public static final int PREEMPT_NULL_DIAGNOSTIC = 0x2;	60	public static final int PREEMPT_NULL_DIAGNOSTIC = 0x2;
57	/**	61	/**
Lines 66-71 Link Here
66	public static final int CAN_ONLY_NON_NULL = 0x0002;	70	public static final int CAN_ONLY_NON_NULL = 0x0002;
67	//check against non null, with definite values -- comparisons	71	//check against non null, with definite values -- comparisons
68	public static final int MAY_NULL = 0x0003;	72	public static final int MAY_NULL = 0x0003;
		73	//check binding a value to a @NonNull variable
		74	public final static int ASSIGN_TO_NONNULL = 0x0080;
69	// check against null, with potential values -- NPE guard	75	// check against null, with potential values -- NPE guard
70	public static final int CHECK_MASK = 0x00FF;	76	public static final int CHECK_MASK = 0x00FF;
71	public static final int IN_COMPARISON_NULL = 0x0100;	77	public static final int IN_COMPARISON_NULL = 0x0100;
Lines 548-553 Link Here
548	// default implementation: do nothing	554	// default implementation: do nothing
549	}	555	}
550		556
		557	protected void recordExpectedType(TypeBinding expectedType, int nullCount) {
		558	if (nullCount == 0) {
		559	this.expectedTypes = new TypeBinding[5];
		560	} else if (this.expectedTypes == null) {
		561	int size = 5;
		562	while (size <= nullCount) size *= 2;
		563	this.expectedTypes = new TypeBinding[size];
		564	}
		565	else if (nullCount == this.expectedTypes.length) {
		566	System.arraycopy(this.expectedTypes, 0,
		567	this.expectedTypes = new TypeBinding[nullCount * 2], 0, nullCount);
		568	}
		569	this.expectedTypes[nullCount] = expectedType;
		570	}
		571
551	protected boolean recordFinalAssignment(VariableBinding variable, Reference finalReference) {	572	protected boolean recordFinalAssignment(VariableBinding variable, Reference finalReference) {
552	return true; // keep going	573	return true; // keep going
553	}	574	}
Lines 746-749 Link Here
746	buffer.append(individualToString()).append('\n');	767	buffer.append(individualToString()).append('\n');
747	return buffer.toString();	768	return buffer.toString();
748	}	769	}
		770
		771	/**
		772	* Record that a nullity mismatch was detected against an annotated type reference.
		773	* @param currentScope scope for error reporting
		774	* @param expression the expression violating the specification
		775	* @param nullStatus the null status of expression at the current location
		776	* @param expectedType the declared type of the spec'ed variable, for error reporting.
		777	*/
		778	public void recordNullityMismatch(BlockScope currentScope, Expression expression, int nullStatus, TypeBinding expectedType) {
		779	if (expression.localVariableBinding() != null) { // flowContext cannot yet handle non-localvar expressions (e.g., fields)
		780	// find the inner-most flowContext that might need deferred handling:
		781	FlowContext currentContext = this;
		782	while (currentContext != null) {
		783	// some flow contexts implement deferred checking, should we participate in that?
		784	if (currentContext.internalRecordNullityMismatch(expression, nullStatus, expectedType, ASSIGN_TO_NONNULL))
		785	return;
		786	currentContext = currentContext.parent;
		787	}
		788	}
		789	// no reason to defer, so report now:
		790	char[][] annotationName = currentScope.environment().getNonNullAnnotationName();
		791	currentScope.problemReporter().nullityMismatch(expression, expectedType, nullStatus, annotationName);
		792	}
		793	protected boolean internalRecordNullityMismatch(Expression expression, int nullStatus, TypeBinding expectedType, int checkType) {
		794	// nop, to be overridden in subclasses
		795	return false; // not recorded
		796	}
749	}	797	}

Lines 12-17 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/flow/LoopingFlowContext.java (+18 lines)
12	package org.eclipse.jdt.internal.compiler.flow;	12	package org.eclipse.jdt.internal.compiler.flow;
13		13
14	import java.util.ArrayList;	14	import java.util.ArrayList;
		15
15	import org.eclipse.jdt.internal.compiler.ast.ASTNode;	16	import org.eclipse.jdt.internal.compiler.ast.ASTNode;
16	import org.eclipse.jdt.internal.compiler.ast.Expression;	17	import org.eclipse.jdt.internal.compiler.ast.Expression;
17	import org.eclipse.jdt.internal.compiler.ast.Reference;	18	import org.eclipse.jdt.internal.compiler.ast.Reference;
Lines 21-26 Link Here
21	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;	22	import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
22	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;	23	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
23	import org.eclipse.jdt.internal.compiler.lookup.Scope;	24	import org.eclipse.jdt.internal.compiler.lookup.Scope;
		25	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
24	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	26	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
25	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;	27	import org.eclipse.jdt.internal.compiler.lookup.VariableBinding;
26		28
Lines 246-251 Link Here
246	continue;	248	continue;
247	}	249	}
248	break;	250	break;
		251	case ASSIGN_TO_NONNULL:
		252	this.parent.recordNullityMismatch(scope, expression, flowInfo.nullStatus(local), this.expectedTypes[i]);
		253	break;
249	default:	254	default:
250	// never happens	255	// never happens
251	}	256	}
Lines 337-342 Link Here
337	this.nullReferences[i] = null;	342	this.nullReferences[i] = null;
338	scope.problemReporter().localVariablePotentialNullReference(local, expression);	343	scope.problemReporter().localVariablePotentialNullReference(local, expression);
339	continue;	344	continue;
		345	}
		346	break;
		347	case ASSIGN_TO_NONNULL:
		348	int nullStatus = flowInfo.nullStatus(local);
		349	if (nullStatus != FlowInfo.NON_NULL) {
		350	char[][] annotationName = scope.environment().getNonNullAnnotationName();
		351	scope.problemReporter().nullityMismatch(expression, this.expectedTypes[i], nullStatus, annotationName);
340	}	352	}
341	break;	353	break;
342	default:	354	default:
Lines 667-670 Link Here
667	public boolean hasEscapingExceptions() {	679	public boolean hasEscapingExceptions() {
668	return this.escapingExceptionCatchSites != null;	680	return this.escapingExceptionCatchSites != null;
669	}	681	}
		682
		683	protected boolean internalRecordNullityMismatch(Expression expression, int nullStatus, TypeBinding expectedType, int checkType) {
		684	recordExpectedType(expectedType, this.nullCount);
		685	recordNullReference(expression.localVariableBinding(), expression, checkType);
		686	return true;
		687	}
670	}	688	}




import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
import org.eclipse.jdt.internal.compiler.util.Util;


	public static final String OPTION_ReportUnclosedCloseable = "org.eclipse.jdt.core.compiler.problem.unclosedCloseable"; //$NON-NLS-1$
	public static final String OPTION_ReportPotentiallyUnclosedCloseable = "org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable"; //$NON-NLS-1$
	public static final String OPTION_ReportExplicitlyClosedAutoCloseable = "org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable"; //$NON-NLS-1$
	public static final String OPTION_ReportNullSpecViolation = "org.eclipse.jdt.core.compiler.problem.nullSpecViolation";  //$NON-NLS-1$
	public static final String OPTION_ReportPotentialNullSpecViolation = "org.eclipse.jdt.core.compiler.problem.potentialNullSpecViolation";  //$NON-NLS-1$
	public static final String OPTION_ReportNullSpecInsufficientInfo = "org.eclipse.jdt.core.compiler.problem.nullSpecInsufficientInfo";  //$NON-NLS-1$
	public static final String OPTION_ReportRedundantNullAnnotation = "org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation";  //$NON-NLS-1$
	public static final String OPTION_AnnotationBasedNullAnalysis = "org.eclipse.jdt.core.compiler.annotation.nullanalysis"; //$NON-NLS-1$
	public static final String OPTION_NullableAnnotationName = "org.eclipse.jdt.core.compiler.annotation.nullable"; //$NON-NLS-1$
	public static final String OPTION_NonNullAnnotationName = "org.eclipse.jdt.core.compiler.annotation.nonnull"; //$NON-NLS-1$
	public static final String OPTION_NonNullByDefaultAnnotationName = "org.eclipse.jdt.core.compiler.annotation.nonnullbydefault"; //$NON-NLS-1$
	// defaults for the above:
	static final char[][] DEFAULT_NULLABLE_ANNOTATION_NAME = CharOperation.splitOn('.', "org.eclipse.jdt.annotation.Nullable".toCharArray()); //$NON-NLS-1$
	static final char[][] DEFAULT_NONNULL_ANNOTATION_NAME = CharOperation.splitOn('.', "org.eclipse.jdt.annotation.NonNull".toCharArray()); //$NON-NLS-1$
	static final char[][] DEFAULT_NONNULLBYDEFAULT_ANNOTATION_NAME = CharOperation.splitOn('.', "org.eclipse.jdt.annotation.NonNullByDefault".toCharArray()); //$NON-NLS-1$
	public static final String OPTION_NonNullIsDefault = "org.eclipse.jdt.core.compiler.annotation.nonnullisdefault";  //$NON-NLS-1$
	/**
	 * Possible values for configurable options
	 */

	public static final int MethodCanBeStatic = IrritantSet.GROUP2 | ASTNode.Bit5;
	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 | ASTNode.Bit6;
	public static final int RedundantSpecificationOfTypeArguments = IrritantSet.GROUP2 | ASTNode.Bit7;
	public static final int UnclosedCloseable = IrritantSet.GROUP2 | ASTNode.Bit8;
	public static final int PotentiallyUnclosedCloseable = IrritantSet.GROUP2 | ASTNode.Bit9;
	public static final int ExplicitlyClosedAutoCloseable = IrritantSet.GROUP2 | ASTNode.Bit10;
	public static final int NullSpecViolation = IrritantSet.GROUP2 | ASTNode.Bit11;
	public static final int PotentialNullSpecViolation = IrritantSet.GROUP2 | ASTNode.Bit12;
	public static final int NullSpecInsufficientInfo = IrritantSet.GROUP2 | ASTNode.Bit13;
	public static final int RedundantNullAnnotation = IrritantSet.GROUP2 | ASTNode.Bit14;

	// Severity level for handlers
	/** 

	public boolean includeNullInfoFromAsserts;
	/** Controls whether forced generic type problems get reported  */
	public boolean reportUnavoidableGenericTypeProblems;

	// === Support for Null Annotations: ===
	/** Master switch for null analysis based on annotations: */
	public boolean isAnnotationBasedNullAnalysisEnabled;
	/** Fully qualified name of annotation to use as marker for nullable types. */
	public char[][] nullableAnnotationName;
	/** Fully qualified name of annotation to use as marker for nonnull types. */
	public char[][] nonNullAnnotationName;
	/** Fully qualified name of annotation to use as marker for default nonnull. */
	public char[][] nonNullByDefaultAnnotationName;
	/** TagBits-encoded default for non-annotated types. */
	public long defaultNonNullness; // 0 or TagBits#AnnotationNonNull

	// keep in sync with warningTokenToIrritant and warningTokenFromIrritant
	public final static String[] warningTokens = {

				return OPTION_ReportPotentiallyUnclosedCloseable;
			case ExplicitlyClosedAutoCloseable :
				return OPTION_ReportExplicitlyClosedAutoCloseable;
			case NullSpecViolation :
				return OPTION_ReportNullSpecViolation;
			case PotentialNullSpecViolation :
				return OPTION_ReportPotentialNullSpecViolation;
			case NullSpecInsufficientInfo :
				return OPTION_ReportNullSpecInsufficientInfo;
			case RedundantNullAnnotation :
				return OPTION_ReportRedundantNullAnnotation;
		}
		return null;
	}

			case NullReference :
			case PotentialNullReference :
			case RedundantNullCheck :
			case NullSpecViolation :
			case PotentialNullSpecViolation :
			case NullSpecInsufficientInfo :
			case RedundantNullAnnotation :
				return "null"; //$NON-NLS-1$
			case FallthroughCase :
				return "fallthrough"; //$NON-NLS-1$

		optionsMap.put(OPTION_ReportUnclosedCloseable, getSeverityString(UnclosedCloseable));
		optionsMap.put(OPTION_ReportPotentiallyUnclosedCloseable, getSeverityString(PotentiallyUnclosedCloseable));
		optionsMap.put(OPTION_ReportExplicitlyClosedAutoCloseable, getSeverityString(ExplicitlyClosedAutoCloseable));
		optionsMap.put(OPTION_AnnotationBasedNullAnalysis, this.isAnnotationBasedNullAnalysisEnabled ? ENABLED : DISABLED);
		if (this.isAnnotationBasedNullAnalysisEnabled) {
			optionsMap.put(OPTION_ReportNullSpecViolation, getSeverityString(NullSpecViolation));
			optionsMap.put(OPTION_ReportPotentialNullSpecViolation, getSeverityString(PotentialNullSpecViolation));
			optionsMap.put(OPTION_ReportNullSpecInsufficientInfo, getSeverityString(NullSpecInsufficientInfo));
			optionsMap.put(OPTION_ReportRedundantNullAnnotation, getSeverityString(RedundantNullAnnotation));
			if (this.nullableAnnotationName != null) {
				char[] compoundName = CharOperation.concatWith(this.nullableAnnotationName, '.');
				optionsMap.put(OPTION_NullableAnnotationName, String.valueOf(compoundName));
			}
			if (this.nonNullAnnotationName != null) {
				char[] compoundName = CharOperation.concatWith(this.nonNullAnnotationName, '.');
				optionsMap.put(OPTION_NonNullAnnotationName, String.valueOf(compoundName));
			}
			if (this.nonNullByDefaultAnnotationName != null) {
				char[] compoundName = CharOperation.concatWith(this.nonNullByDefaultAnnotationName, '.');
				optionsMap.put(OPTION_NonNullByDefaultAnnotationName, String.valueOf(compoundName));
			}
			if (this.defaultNonNullness == TagBits.AnnotationNonNull)
				optionsMap.put(OPTION_NonNullIsDefault, CompilerOptions.ENABLED);
			else
				optionsMap.put(OPTION_NonNullIsDefault, CompilerOptions.DISABLED);
		}
		return optionsMap;
	}


		if ((optionValue = optionsMap.get(OPTION_ReportUnclosedCloseable)) != null) updateSeverity(UnclosedCloseable, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportPotentiallyUnclosedCloseable)) != null) updateSeverity(PotentiallyUnclosedCloseable, optionValue);
		if ((optionValue = optionsMap.get(OPTION_ReportExplicitlyClosedAutoCloseable)) != null) updateSeverity(ExplicitlyClosedAutoCloseable, optionValue);
		if ((optionValue = optionsMap.get(OPTION_AnnotationBasedNullAnalysis)) != null) {
			if (ENABLED.equals(optionValue)) {
				this.isAnnotationBasedNullAnalysisEnabled = true;
				// ensure that we actually have annotation names to use:
				ensureNullAnnotationNames();
			} else if (DISABLED.equals(optionValue)) {
				this.isAnnotationBasedNullAnalysisEnabled = false;
			}
		}
		if (this.isAnnotationBasedNullAnalysisEnabled) {
			if ((optionValue = optionsMap.get(OPTION_ReportNullSpecViolation)) != null) updateSeverity(NullSpecViolation, optionValue);
			if ((optionValue = optionsMap.get(OPTION_ReportPotentialNullSpecViolation)) != null) updateSeverity(PotentialNullSpecViolation, optionValue);
			if ((optionValue = optionsMap.get(OPTION_ReportNullSpecInsufficientInfo)) != null) updateSeverity(NullSpecInsufficientInfo, optionValue);
			if ((optionValue = optionsMap.get(OPTION_ReportRedundantNullAnnotation)) != null) updateSeverity(RedundantNullAnnotation, optionValue);
			if ((optionValue = optionsMap.get(OPTION_NullableAnnotationName)) != null) {
				this.nullableAnnotationName = CharOperation.splitAndTrimOn('.', ((String)optionValue).toCharArray());
			}
			if ((optionValue = optionsMap.get(OPTION_NonNullAnnotationName)) != null) {
				this.nonNullAnnotationName = CharOperation.splitAndTrimOn('.', ((String)optionValue).toCharArray());
			}
			if ((optionValue = optionsMap.get(OPTION_NonNullByDefaultAnnotationName)) != null) {
				this.nonNullByDefaultAnnotationName = CharOperation.splitAndTrimOn('.', ((String)optionValue).toCharArray());
			}
			if ((optionValue = optionsMap.get(OPTION_NonNullIsDefault)) != null) {
				if (CompilerOptions.ENABLED.equals(optionValue)) {
					this.defaultNonNullness = TagBits.AnnotationNonNull;
					ensureNullAnnotationNames();
				} else {
					this.defaultNonNullness = 0;
				}
			}
		}

		// Javadoc options
		if ((optionValue = optionsMap.get(OPTION_DocCommentSupport)) != null) {

			}
		}
	}
	private void ensureNullAnnotationNames() {
		if (this.nullableAnnotationName == null)
			this.nullableAnnotationName = CompilerOptions.DEFAULT_NULLABLE_ANNOTATION_NAME;
		if (this.nonNullAnnotationName == null)
			this.nonNullAnnotationName = CompilerOptions.DEFAULT_NONNULL_ANNOTATION_NAME;
		if (this.nonNullByDefaultAnnotationName == null)
			this.nonNullByDefaultAnnotationName = CompilerOptions.DEFAULT_NONNULLBYDEFAULT_ANNOTATION_NAME;
	}
	public String toString() {
		StringBuffer buf = new StringBuffer("CompilerOptions:"); //$NON-NLS-1$
		buf.append("\n\t- local variables debug attributes: ").append((this.produceDebugAttributes & ClassFileConstants.ATTR_VARS) != 0 ? "ON" : " OFF"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

Lines 102-109 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java (-3 / +14 lines)
102	.set(	102	.set(
103	CompilerOptions.DeadCode	103	CompilerOptions.DeadCode
104	\|CompilerOptions.Tasks	104	\|CompilerOptions.Tasks
105	\|CompilerOptions.UnclosedCloseable);	105	\|CompilerOptions.UnclosedCloseable
106		106	\|CompilerOptions.NullSpecInsufficientInfo
		107	\|CompilerOptions.RedundantNullAnnotation);
		108	// default errors IF AnnotationBasedNullAnalysis is enabled:
		109	COMPILER_DEFAULT_ERRORS.set(
		110	CompilerOptions.NullSpecViolation
		111	\|CompilerOptions.PotentialNullSpecViolation);
		112
107	ALL.setAll();	113	ALL.setAll();
108	HIDING	114	HIDING
109	.set(CompilerOptions.FieldHiding)	115	.set(CompilerOptions.FieldHiding)
Lines 111-117 Link Here
111	.set(CompilerOptions.TypeHiding);	117	.set(CompilerOptions.TypeHiding);
112	NULL	118	NULL
113	.set(CompilerOptions.PotentialNullReference)	119	.set(CompilerOptions.PotentialNullReference)
114	.set(CompilerOptions.RedundantNullCheck);	120	.set(CompilerOptions.RedundantNullCheck)
		121	.set(CompilerOptions.NullSpecViolation)
		122	.set(CompilerOptions.PotentialNullSpecViolation)
		123	.set(CompilerOptions.NullSpecInsufficientInfo)
		124	.set(CompilerOptions.RedundantNullAnnotation);
		125
115	RESTRICTION.set(CompilerOptions.DiscouragedReference);	126	RESTRICTION.set(CompilerOptions.DiscouragedReference);
116	STATIC_ACCESS.set(CompilerOptions.NonStaticAccessToStatic);	127	STATIC_ACCESS.set(CompilerOptions.NonStaticAccessToStatic);
117	UNUSED	128	UNUSED

Lines 16-21 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java (+96 lines)
16	import org.eclipse.jdt.core.compiler.CharOperation;	16	import org.eclipse.jdt.core.compiler.CharOperation;
17	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	17	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
18	import org.eclipse.jdt.internal.compiler.env.*;	18	import org.eclipse.jdt.internal.compiler.env.*;
		19	import org.eclipse.jdt.internal.compiler.impl.BooleanConstant;
19	import org.eclipse.jdt.internal.compiler.impl.Constant;	20	import org.eclipse.jdt.internal.compiler.impl.Constant;
20	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;	21	import org.eclipse.jdt.internal.compiler.problem.AbortCompilation;
21	import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;	22	import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
Lines 383-388 Link Here
383	}	384	}
384	if (this.environment.globalOptions.storeAnnotations)	385	if (this.environment.globalOptions.storeAnnotations)
385	setAnnotations(createAnnotations(binaryType.getAnnotations(), this.environment, missingTypeNames));	386	setAnnotations(createAnnotations(binaryType.getAnnotations(), this.environment, missingTypeNames));
		387
		388	scanTypeForNullAnnotation(binaryType);
386	} finally {	389	} finally {
387	// protect against incorrect use of the needFieldsAndMethods flag, see 48459	390	// protect against incorrect use of the needFieldsAndMethods flag, see 48459
388	if (this.fields == null)	391	if (this.fields == null)
Lines 589-594 Link Here
589	// fixup the declaring element of the type variable	592	// fixup the declaring element of the type variable
590	for (int i = 0, length = typeVars.length; i < length; i++)	593	for (int i = 0, length = typeVars.length; i < length; i++)
591	typeVars[i].declaringElement = result;	594	typeVars[i].declaringElement = result;
		595
		596	scanMethodForNullAnnotation(method, result);
		597
592	return result;	598	return result;
593	}	599	}
594		600
Lines 1142-1147 Link Here
1142	}	1148	}
1143	return this.storedAnnotations;	1149	return this.storedAnnotations;
1144	}	1150	}
		1151	void scanMethodForNullAnnotation(IBinaryMethod method, MethodBinding methodBinding) {
		1152	char[][] nullableAnnotationName = this.environment.getNullableAnnotationName();
		1153	char[][] nonNullAnnotationName = this.environment.getNonNullAnnotationName();
		1154	if (nullableAnnotationName == null \|\| nonNullAnnotationName == null)
		1155	return; // not configured to use null annotations
		1156
		1157	// return:
		1158	IBinaryAnnotation[] annotations = method.getAnnotations();
		1159	if (annotations != null) {
		1160	for (int i = 0; i < annotations.length; i++) {
		1161	char[] annotationTypeName = annotations[i].getTypeName();
		1162	if (annotationTypeName[0] != 'L')
		1163	continue;
		1164	char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
		1165	if (CharOperation.equals(typeName, nonNullAnnotationName)) {
		1166	methodBinding.tagBits \|= TagBits.AnnotationNonNull;
		1167	break;
		1168	}
		1169	if (CharOperation.equals(typeName, nullableAnnotationName)) {
		1170	methodBinding.tagBits \|= TagBits.AnnotationNullable;
		1171	break;
		1172	}
		1173	}
		1174	}
		1175
		1176	// parameters:
		1177	TypeBinding[] parameters = methodBinding.parameters;
		1178	for (int j = 0; j < parameters.length; j++) {
		1179	IBinaryAnnotation[] paramAnnotations = method.getParameterAnnotations(j);
		1180	if (paramAnnotations != null) {
		1181	for (int i = 0; i < paramAnnotations.length; i++) {
		1182	char[] annotationTypeName = paramAnnotations[i].getTypeName();
		1183	if (annotationTypeName[0] != 'L')
		1184	continue;
		1185	char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
		1186	if (CharOperation.equals(typeName, nonNullAnnotationName)) {
		1187	if (methodBinding.parameterNonNullness == null)
		1188	methodBinding.parameterNonNullness = new Boolean[parameters.length];
		1189	methodBinding.parameterNonNullness[j] = Boolean.TRUE;
		1190	break;
		1191	} else if (CharOperation.equals(typeName, nullableAnnotationName)) {
		1192	if (methodBinding.parameterNonNullness == null)
		1193	methodBinding.parameterNonNullness = new Boolean[parameters.length];
		1194	methodBinding.parameterNonNullness[j] = Boolean.FALSE;
		1195	break;
		1196	}
		1197	}
		1198	}
		1199	}
		1200	}
		1201	void scanTypeForNullAnnotation(IBinaryType binaryType) {
		1202	char[][] nonNullByDefaultAnnotationName = this.environment.getNonNullByDefaultAnnotationName();
		1203	if (nonNullByDefaultAnnotationName == null)
		1204	return; // not configured to use null annotations
		1205
		1206	IBinaryAnnotation[] annotations = binaryType.getAnnotations();
		1207	if (annotations != null) {
		1208	long annotationBit = 0L;
		1209	TypeBinding defaultNullness = null;
		1210	for (int i = 0; i < annotations.length; i++) {
		1211	char[] annotationTypeName = annotations[i].getTypeName();
		1212	if (annotationTypeName[0] != 'L')
		1213	continue;
		1214	char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
1215	if (CharOperation.equals(typeName, nonNullByDefaultAnnotationName)) {
1216	IBinaryElementValuePair[] elementValuePairs = annotations[i].getElementValuePairs();
1217	if (elementValuePairs != null && elementValuePairs.length == 1) {
1218	Object value = elementValuePairs[0].getValue();
1219	if (value instanceof BooleanConstant
1220	&& !((BooleanConstant)value).booleanValue())
1221	{
1222	// parameter is 'false': this means we cancel defaults from outer scopes:
1223	annotationBit = TagBits.AnnotationNullUnspecifiedByDefault;
1224	defaultNullness = ReferenceBinding.NULL_UNSPECIFIED;
1225	break;
1226	}
1227	}
1228	annotationBit = TagBits.AnnotationNonNullByDefault;
1229	defaultNullness = this.environment.getNullAnnotationBinding(TagBits.AnnotationNonNull, false/resolve/);
1230	break;
1231	}
1232	}
1233	if (annotationBit != 0L) {
1234	this.tagBits \|= annotationBit;
1235	if (CharOperation.equals(this.sourceName(), TypeConstants.PACKAGE_INFO_NAME))
1236	this.getPackage().nullnessDefaultAnnotation = defaultNullness;
1237	}
1238	}
1239	}
1240
1145	/* Answer the receiver's superclass... null if the receiver is Object or an interface.	1241	/* Answer the receiver's superclass... null if the receiver is Object or an interface.
1146	*	1242	*
1147	* NOTE: superclass of a binary type is resolved when needed	1243	* NOTE: superclass of a binary type is resolved when needed

Lines 76-81 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java (+91 lines)
76	public boolean isProcessingAnnotations = false;	76	public boolean isProcessingAnnotations = false;
77	public boolean mayTolerateMissingType = false;	77	public boolean mayTolerateMissingType = false;
78		78
		79	boolean nullAnnotationsInitialized = false;
		80
79	final static int BUILD_FIELDS_AND_METHODS = 4;	81	final static int BUILD_FIELDS_AND_METHODS = 4;
80	final static int BUILD_TYPE_HIERARCHY = 1;	82	final static int BUILD_TYPE_HIERARCHY = 1;
81	final static int CHECK_AND_SET_IMPORTS = 2;	83	final static int CHECK_AND_SET_IMPORTS = 2;
Lines 83-88 Link Here
83		85
84	static final ProblemPackageBinding TheNotFoundPackage = new ProblemPackageBinding(CharOperation.NO_CHAR, NotFound);	86	static final ProblemPackageBinding TheNotFoundPackage = new ProblemPackageBinding(CharOperation.NO_CHAR, NotFound);
85	static final ProblemReferenceBinding TheNotFoundType = new ProblemReferenceBinding(CharOperation.NO_CHAR_CHAR, null, NotFound);	87	static final ProblemReferenceBinding TheNotFoundType = new ProblemReferenceBinding(CharOperation.NO_CHAR_CHAR, null, NotFound);
		88
86		89
87	public LookupEnvironment(ITypeRequestor typeRequestor, CompilerOptions globalOptions, ProblemReporter problemReporter, INameEnvironment nameEnvironment) {	90	public LookupEnvironment(ITypeRequestor typeRequestor, CompilerOptions globalOptions, ProblemReporter problemReporter, INameEnvironment nameEnvironment) {
88	this.typeRequestor = typeRequestor;	91	this.typeRequestor = typeRequestor;
Lines 723-728 Link Here
723	* 3. Create the method bindings	726	* 3. Create the method bindings
724	*/	727	*/
725	public PackageBinding createPackage(char[][] compoundName) {	728	public PackageBinding createPackage(char[][] compoundName) {
		729	if (!this.nullAnnotationsInitialized)
		730	initNullAnnotationPackages();
726	PackageBinding packageBinding = getPackage0(compoundName[0]);	731	PackageBinding packageBinding = getPackage0(compoundName[0]);
727	if (packageBinding == null \|\| packageBinding == TheNotFoundPackage) {	732	if (packageBinding == null \|\| packageBinding == TheNotFoundPackage) {
728	packageBinding = new PackageBinding(compoundName[0], this);	733	packageBinding = new PackageBinding(compoundName[0], this);
Lines 1073-1078 Link Here
1073	return packageBinding.getType0(compoundName[compoundName.length - 1]);	1078	return packageBinding.getType0(compoundName[compoundName.length - 1]);
1074	}	1079	}
1075		1080
		1081	public char[][] getNullableAnnotationName() {
		1082	return this.globalOptions.nullableAnnotationName;
		1083	}
		1084
		1085	public char[][] getNonNullAnnotationName() {
		1086	return this.globalOptions.nonNullAnnotationName;
		1087	}
		1088
		1089	public char[][] getNonNullByDefaultAnnotationName() {
		1090	return this.globalOptions.nonNullByDefaultAnnotationName;
		1091	}
		1092
		1093	/**
		1094	* Answer the type binding representing the null-annotation identified by the given tag bits.
		1095	* @param annotationTagBit tag bits potentially denoting a null-annotation
		1096	* @param resolve should the resulting type binding be resolved?
		1097	* @return the corresponding annotation type binding
		1098	* or <code>null</code> if no annotation bits are contained in the given tag bits.
		1099	*/
		1100	public TypeBinding getNullAnnotationBinding(long annotationTagBit, boolean resolve) {
		1101	char[][] name = null;
		1102	if (annotationTagBit == TagBits.AnnotationNonNull)
		1103	name = getNonNullAnnotationName();
		1104	else if (annotationTagBit == TagBits.AnnotationNullable)
		1105	name = getNullableAnnotationName();
		1106	else
		1107	return null;
		1108	if (resolve)
		1109	return getType(name);
		1110	else
		1111	return getTypeFromCompoundName(name, false, false);
		1112	}
		1113
		1114	/**
		1115	* Inspect the given tag bits and answer a corresponding null annotation type binding
		1116	* @param defaultTagBit tag bits representing the default applicable at the current code location
		1117	* @param resolve should the resulting type binding be resolved?
		1118	* @return the corresponding concrete annotation type binding (<code>@NonNull</code> or <code>@Nullable</code>)
		1119	* or <code>null</code> if no bits of a default-annotation are contained in the given tag bits.
		1120	*/
		1121	public TypeBinding getNullAnnotationBindingFromDefault(long defaultTagBit, boolean resolve) {
		1122	if ((defaultTagBit & TagBits.AnnotationNullUnspecifiedByDefault) != 0)
		1123	return ReferenceBinding.NULL_UNSPECIFIED;
		1124	if ((defaultTagBit & TagBits.AnnotationNonNullByDefault) != 0)
		1125	return getNullAnnotationBinding(TagBits.AnnotationNonNull, resolve);
		1126	return null;
		1127	}
		1128
1076	/* Answer the top level package named name if it exists in the cache.	1129	/* Answer the top level package named name if it exists in the cache.
1077	* Answer theNotFoundPackage if it could not be resolved the first time	1130	* Answer theNotFoundPackage if it could not be resolved the first time
1078	* it was looked up, otherwise answer null.	1131	* it was looked up, otherwise answer null.
Lines 1106-1111 Link Here
1106	* Answer null if the package cannot be found.	1159	* Answer null if the package cannot be found.
1107	*/	1160	*/
1108	PackageBinding getTopLevelPackage(char[] name) {	1161	PackageBinding getTopLevelPackage(char[] name) {
		1162	if (!this.nullAnnotationsInitialized)
		1163	initNullAnnotationPackages();
1109	PackageBinding packageBinding = getPackage0(name);	1164	PackageBinding packageBinding = getPackage0(name);
1110	if (packageBinding != null) {	1165	if (packageBinding != null) {
1111	if (packageBinding == TheNotFoundPackage)	1166	if (packageBinding == TheNotFoundPackage)
Lines 1387-1392 Link Here
1387	}	1442	}
1388	}	1443	}
1389		1444
		1445	private void initNullAnnotationPackages() {
		1446	this.nullAnnotationsInitialized = true;
		1447	char[][] compoundName = getNullableAnnotationName();
		1448	if (compoundName != null)
		1449	initNullAnnotationPackage(compoundName, TypeIds.T_ConfiguredAnnotationNullable);
		1450	compoundName = getNonNullAnnotationName();
		1451	if (compoundName != null)
		1452	initNullAnnotationPackage(compoundName, TypeIds.T_ConfiguredAnnotationNonNull);
		1453	compoundName = getNonNullByDefaultAnnotationName();
		1454	if (compoundName != null)
		1455	initNullAnnotationPackage(compoundName, TypeIds.T_ConfiguredAnnotationNonNullByDefault);
		1456	}
		1457
		1458	/**
		1459	* Create or retrieve the package holding the specified type and store the type name.
		1460	*/
		1461	void initNullAnnotationPackage(char[][] typeName, int typeId) {
		1462	if (typeName.length < 2) {
		1463	this.problemReporter.nullAnnotationNameMustBeQualified(typeName);
		1464	return;
		1465	}
		1466	char[][] packageName = CharOperation.subarray(typeName, 0, typeName.length-1);
		1467	PackageBinding packageBinding = createPackage(packageName);
		1468	char[] simpleTypeName = typeName[typeName.length-1];
		1469	if (typeId == TypeIds.T_ConfiguredAnnotationNullable)
		1470	packageBinding.nullableName = simpleTypeName;
		1471	else if (typeId == TypeIds.T_ConfiguredAnnotationNonNull)
		1472	packageBinding.nonNullName = simpleTypeName;
		1473	else if (typeId == TypeIds.T_ConfiguredAnnotationNonNullByDefault)
		1474	packageBinding.nonNullByDefaultName = simpleTypeName;
		1475	}
		1476
		1477
1390	boolean isMissingType(char[] typeName) {	1478	boolean isMissingType(char[] typeName) {
1391	for (int i = this.missingTypes == null ? 0 : this.missingTypes.size(); --i >= 0;) {	1479	for (int i = this.missingTypes == null ? 0 : this.missingTypes.size(); --i >= 0;) {
1392	MissingTypeBinding missingType = (MissingTypeBinding) this.missingTypes.get(i);	1480	MissingTypeBinding missingType = (MissingTypeBinding) this.missingTypes.get(i);
Lines 1454-1459 Link Here
1454	this.unitBeingCompleted = null; // in case AbortException occurred	1542	this.unitBeingCompleted = null; // in case AbortException occurred
1455		1543
1456	this.classFilePool.reset();	1544	this.classFilePool.reset();
		1545
		1546	this.nullAnnotationsInitialized = false;
		1547
1457	// name environment has a longer life cycle, and must be reset in	1548	// name environment has a longer life cycle, and must be reset in
1458	// the code which created it.	1549	// the code which created it.
1459	}	1550	}

Lines 34-39 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java (+38 lines)
34	char[] signature;	34	char[] signature;
35	public long tagBits;	35	public long tagBits;
36		36
		37	/** Store nullness information from annotation (incl. applicable default). */
		38	public Boolean[] parameterNonNullness; // TRUE means @NonNull declared, FALSE means @Nullable declared, null means nothing declared
		39
37	protected MethodBinding() {	40	protected MethodBinding() {
38	// for creating problem or synthetic method	41	// for creating problem or synthetic method
39	}	42	}
Lines 439-444 Link Here
439	return this.selector;	442	return this.selector;
440	}	443	}
441		444
		445	/**
		446	* After method verifier has finished, fill in missing nullness values from the applicable default.
		447	* @param annotationBinding the null annotation specified to be the default at the current code location.
		448	*/
		449	protected void fillInDefaultNonNullness(TypeBinding annotationBinding) {
		450	if (this.parameterNonNullness == null)
		451	this.parameterNonNullness = new Boolean[this.parameters.length];
		452	AbstractMethodDeclaration sourceMethod = sourceMethod();
		453	for (int i = 0; i < this.parameterNonNullness.length; i++) {
		454	if (this.parameters[i].isBaseType())
		455	continue;
		456	boolean added = false;
		457	if (this.parameterNonNullness[i] == null) {
		458	added = true;
		459	this.parameterNonNullness[i] = Boolean.TRUE;
		460	if (sourceMethod != null)
		461	sourceMethod.addParameterNonNullAnnotation(i, (ReferenceBinding)annotationBinding);
		462	} else if (this.parameterNonNullness[i].booleanValue()) {
		463	sourceMethod.scope.problemReporter().nullAnnotationIsRedundant(sourceMethod, i);
		464	}
		465	if (added)
		466	this.tagBits \|= TagBits.HasParameterAnnotations;
		467	}
		468	if ( this.returnType != null
		469	&& !this.returnType.isBaseType()
		470	&& (this.tagBits & (TagBits.AnnotationNonNull\|TagBits.AnnotationNullable)) == 0)
		471	{
		472	this.tagBits \|= TagBits.AnnotationNonNull;
		473	if (sourceMethod != null)
		474	sourceMethod.addNullnessAnnotation((ReferenceBinding)annotationBinding);
		475	} else if ((this.tagBits & TagBits.AnnotationNonNull) != 0) {
		476	sourceMethod.scope.problemReporter().nullAnnotationIsRedundant(sourceMethod, -1/signifies method return/);
		477	}
		478	}
		479
442	public MethodBinding findOriginalInheritedMethod(MethodBinding inheritedMethod) {	480	public MethodBinding findOriginalInheritedMethod(MethodBinding inheritedMethod) {
443	MethodBinding inheritedOriginal = inheritedMethod.original();	481	MethodBinding inheritedOriginal = inheritedMethod.original();
444	TypeBinding superType = this.declaringClass.findSuperTypeOriginatingFrom(inheritedOriginal.declaringClass);	482	TypeBinding superType = this.declaringClass.findSuperTypeOriginatingFrom(inheritedOriginal.declaringClass);

Lines 164-169 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java (-1 / +97 lines)
164	\|\| this.type.superclass.erasure().findSuperTypeOriginatingFrom(originalInherited.declaringClass) == null)	164	\|\| this.type.superclass.erasure().findSuperTypeOriginatingFrom(originalInherited.declaringClass) == null)
165	this.type.addSyntheticBridgeMethod(originalInherited, concreteMethod.original());	165	this.type.addSyntheticBridgeMethod(originalInherited, concreteMethod.original());
166	}	166	}
		167	if (!concreteMethod.isStatic() && !abstractMethod.isStatic())
		168	checkNullSpecInheritance(concreteMethod, abstractMethod);
167	}	169	}
168	}	170	}
169	void checkForBridgeMethod(MethodBinding currentMethod, MethodBinding inheritedMethod, MethodBinding[] allInheritedMethods) {	171	void checkForBridgeMethod(MethodBinding currentMethod, MethodBinding inheritedMethod, MethodBinding[] allInheritedMethods) {
Lines 358-363 Link Here
358	}	360	}
359		361
360	return false;	362	return false;
		363	}
		364	void checkAgainstInheritedMethods(MethodBinding currentMethod, MethodBinding[] methods, int length, MethodBinding[] allInheritedMethods)
		365	{
		366	super.checkAgainstInheritedMethods(currentMethod, methods, length, allInheritedMethods);
		367	for (int i = length; --i >= 0;)
		368	if (!currentMethod.isStatic() && !methods[i].isStatic())
		369	checkNullSpecInheritance(currentMethod, methods[i]);
		370	}
		371
		372	void checkNullSpecInheritance(MethodBinding currentMethod, MethodBinding inheritedMethod) {
		373	long inheritedBits = inheritedMethod.tagBits;
		374	long currentBits = currentMethod.tagBits;
		375	AbstractMethodDeclaration srcMethod = null;
		376	if (this.type.equals(currentMethod.declaringClass)) // is currentMethod from the current type?
		377	srcMethod = currentMethod.sourceMethod();
		378
		379	// return type:
		380	if ((inheritedBits & TagBits.AnnotationNonNull) != 0) {
		381	long currentNullBits = currentBits & (TagBits.AnnotationNonNull\|TagBits.AnnotationNullable);
		382	if (currentNullBits != TagBits.AnnotationNonNull) {
		383	if (srcMethod != null) {
		384	this.type.scope.problemReporter().illegalReturnRedefinition(srcMethod, inheritedMethod,
		385	this.environment.getNonNullAnnotationName());
		386	} else {
		387	this.type.scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod);
		388	return;
		389	}
		390	}
		391	}
		392
		393	// parameters:
		394	Argument[] currentArguments = srcMethod == null ? null : srcMethod.arguments;
		395	if (inheritedMethod.parameterNonNullness != null) {
		396	// inherited method has null-annotations, check compatibility:
		397
		398	for (int i = 0; i < inheritedMethod.parameterNonNullness.length; i++) {
		399	Argument currentArgument = currentArguments == null ? null : currentArguments[i];
		400
		401	Boolean inheritedNonNullNess = inheritedMethod.parameterNonNullness[i];
		402	Boolean currentNonNullNess = (currentMethod.parameterNonNullness == null)
		403	? null : currentMethod.parameterNonNullness[i];
		404	if (inheritedNonNullNess != null) { // super has a null annotation
		405	if (currentNonNullNess == null) { // current parameter lacks null annotation
		406	boolean needNonNull = false;
		407	char[][] annotationName;
		408	if (inheritedNonNullNess == Boolean.TRUE) {
		409	needNonNull = true;
		410	annotationName = this.environment.getNonNullAnnotationName();
		411	} else {
		412	annotationName = this.environment.getNullableAnnotationName();
		413	}
		414	if (currentArgument != null) {
		415	this.type.scope.problemReporter().parameterLackingNonNullAnnotation(
		416	currentArgument,
		417	inheritedMethod.declaringClass,
		418	needNonNull,
		419	annotationName);
		420	continue;
		421	} else {
		422	this.type.scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod);
		423	break;
		424	}
		425	}
		426	}
427	if (inheritedNonNullNess != Boolean.TRUE) { // super parameter is not restricted to @NonNull
428	if (currentNonNullNess == Boolean.TRUE) { // current parameter is restricted to @NonNull
429	if (currentArgument != null)
430	this.type.scope.problemReporter().illegalRedefinitionToNonNullParameter(
431	currentArgument,
432	inheritedMethod.declaringClass,
433	inheritedNonNullNess == null
434	? null
435	: this.environment.getNullableAnnotationName());
436	else
437	this.type.scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod);
438	}
439	}
440	}
441	} else if (currentMethod.parameterNonNullness != null) {
442	// super method has no annotations but current has
443	for (int i = 0; i < currentMethod.parameterNonNullness.length; i++) {
444	if (currentMethod.parameterNonNullness[i] == Boolean.TRUE) { // tightening from unconstrained to @NonNull
445	if (currentArguments != null) {
446	this.type.scope.problemReporter().illegalRedefinitionToNonNullParameter(
447	currentArguments[i],
448	inheritedMethod.declaringClass,
449	null);
450	} else {
451	this.type.scope.problemReporter().cannotImplementIncompatibleNullness(currentMethod, inheritedMethod);
452	break;
453	}
454	}
455	}
456	}
361	}	457	}
362		458
363	void reportRawReferences() {	459	void reportRawReferences() {
Lines 932-938 Link Here
932	boolean isUnsafeReturnTypeOverride(MethodBinding currentMethod, MethodBinding inheritedMethod) {	1028	boolean isUnsafeReturnTypeOverride(MethodBinding currentMethod, MethodBinding inheritedMethod) {
933	// called when currentMethod's return type is NOT compatible with inheritedMethod's return type	1029	// called when currentMethod's return type is NOT compatible with inheritedMethod's return type
934		1030
935	// JLS 3 �8.4.5: more are accepted, with an unchecked conversion	1031	// JLS 3 �8.4.5: more are accepted, with an unchecked conversion
936	if (currentMethod.returnType == inheritedMethod.returnType.erasure()) {	1032	if (currentMethod.returnType == inheritedMethod.returnType.erasure()) {
937	TypeBinding[] currentParams = currentMethod.parameters;	1033	TypeBinding[] currentParams = currentMethod.parameters;
938	TypeBinding[] inheritedParams = inheritedMethod.parameters;	1034	TypeBinding[] inheritedParams = inheritedMethod.parameters;

Lines 1-5 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/PackageBinding.java (-1 / +29 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 22-27 Link Here
22	public LookupEnvironment environment;	22	public LookupEnvironment environment;
23	HashtableOfType knownTypes;	23	HashtableOfType knownTypes;
24	HashtableOfPackage knownPackages;	24	HashtableOfPackage knownPackages;
		25
		26	protected char[] nullableName = null;
		27	protected char[] nonNullName = null;
		28	protected char[] nonNullByDefaultName = null;
		29	protected TypeBinding nullnessDefaultAnnotation;
		30
25	protected PackageBinding() {	31	protected PackageBinding() {
26	// for creating problem package	32	// for creating problem package
27	}	33	}
Lines 58-63 Link Here
58	if (this.knownTypes == null)	64	if (this.knownTypes == null)
59	this.knownTypes = new HashtableOfType(25);	65	this.knownTypes = new HashtableOfType(25);
60	this.knownTypes.put(element.compoundName[element.compoundName.length - 1], element);	66	this.knownTypes.put(element.compoundName[element.compoundName.length - 1], element);
		67	if (this.nullableName != null \|\| this.nonNullName != null \|\| this.nonNullByDefaultName != null)
		68	setupNullAnnotationType(element);
61	}	69	}
62		70
63	void clearMissingTagBit() {	71	void clearMissingTagBit() {
Lines 230-235 Link Here
230	return ProblemReasons.NoError;	238	return ProblemReasons.NoError;
231	}	239	}
232		240
		241	void setupNullAnnotationType(ReferenceBinding type) {
		242	int id = 0;
		243	if (CharOperation.equals(this.nullableName, type.sourceName))
		244	id = TypeIds.T_ConfiguredAnnotationNullable;
		245	else if (CharOperation.equals(this.nonNullName, type.sourceName))
		246	id = TypeIds.T_ConfiguredAnnotationNonNull;
		247	else if (CharOperation.equals(this.nonNullByDefaultName, type.sourceName))
		248	id = TypeIds.T_ConfiguredAnnotationNonNullByDefault;
		249	else
		250	return;
		251
		252	type.id = id; // ensure annotations of this type are detected as standard annotations.
		253	}
		254
		255	public TypeBinding getNullnessDefaultAnnotation() {
		256	if (this.nullnessDefaultAnnotation instanceof UnresolvedReferenceBinding)
		257	return this.nullnessDefaultAnnotation = BinaryTypeBinding.resolveType(this.nullnessDefaultAnnotation, this.environment, false);
		258	return this.nullnessDefaultAnnotation;
		259	}
		260
233	public char[] readableName() /java.lang/ {	261	public char[] readableName() /java.lang/ {
234	return CharOperation.concatWith(this.compoundName, '.');	262	return CharOperation.concatWith(this.compoundName, '.');
235	}	263	}

Lines 48-53 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ReferenceBinding.java (+8 lines)
48	public boolean hasTypeBit(int bit) { return false; }	48	public boolean hasTypeBit(int bit) { return false; }
49	};	49	};
50		50
		51	/**
		52	* This faked annotation type binding marks types with unspecified nullness.
		53	* For use in {@link PackageBinding#nullnessDefaultAnnotation} and {@link SourceTypeBinding#nullnessDefaultAnnotation}
		54	*/
		55	final static ReferenceBinding NULL_UNSPECIFIED = new ReferenceBinding() { /* faked type binding */
		56	public boolean hasTypeBit(int bit) { return false; }
		57	};
		58
51	private static final Comparator FIELD_COMPARATOR = new Comparator() {	59	private static final Comparator FIELD_COMPARATOR = new Comparator() {
52	public int compare(Object o1, Object o2) {	60	public int compare(Object o1, Object o2) {
53	char[] n1 = ((FieldBinding) o1).name;	61	char[] n1 = ((FieldBinding) o1).name;

Lines 54-59 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (+97 lines)
54	char[] genericReferenceTypeSignature;	54	char[] genericReferenceTypeSignature;
55		55
56	private SimpleLookupTable storedAnnotations = null; // keys are this ReferenceBinding & its fields and methods, value is an AnnotationHolder	56	private SimpleLookupTable storedAnnotations = null; // keys are this ReferenceBinding & its fields and methods, value is an AnnotationHolder
		57
		58	private TypeBinding nullnessDefaultAnnotation;
		59	private int nullnessDefaultInitialized = 0; // 0: nothing; 1: type; 2: package
57		60
58	public SourceTypeBinding(char[][] compoundName, PackageBinding fPackage, ClassScope scope) {	61	public SourceTypeBinding(char[][] compoundName, PackageBinding fPackage, ClassScope scope) {
59	this.compoundName = compoundName;	62	this.compoundName = compoundName;
Lines 781-786 Link Here
781	}	784	}
782	if ((this.tagBits & TagBits.AnnotationDeprecated) != 0)	785	if ((this.tagBits & TagBits.AnnotationDeprecated) != 0)
783	this.modifiers \|= ClassFileConstants.AccDeprecated;	786	this.modifiers \|= ClassFileConstants.AccDeprecated;
		787	evaluateNullAnnotations(this.tagBits);
784	}	788	}
785	return this.tagBits;	789	return this.tagBits;
786	}	790	}
Lines 1088-1093 Link Here
1088	this.modifiers \|= ClassFileConstants.AccDeprecated;	1092	this.modifiers \|= ClassFileConstants.AccDeprecated;
1089	}	1093	}
1090	}	1094	}
		1095	if (CharOperation.equals(this.sourceName, TypeConstants.PACKAGE_INFO_NAME))
		1096	getAnnotationTagBits(); // initialize
1091	}	1097	}
1092		1098
1093	// ensure the receiver knows its hierarchy & fields/methods so static imports can be resolved correctly	1099	// ensure the receiver knows its hierarchy & fields/methods so static imports can be resolved correctly
Lines 1590-1601 Link Here
1590	typeParameters[i].binding = null;	1596	typeParameters[i].binding = null;
1591	return null;	1597	return null;
1592	}	1598	}
		1599	callBindArguments(method);
1593	if (foundReturnTypeProblem)	1600	if (foundReturnTypeProblem)
1594	return method; // but its still unresolved with a null return type & is still connected to its method declaration	1601	return method; // but its still unresolved with a null return type & is still connected to its method declaration
1595		1602
1596	method.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;	1603	method.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
1597	return method;	1604	return method;
1598	}	1605	}
		1606	private void callBindArguments(MethodBinding method) {
		1607	switch (this.nullnessDefaultInitialized) {
		1608	case 0:
		1609	getAnnotationTagBits(); // initialize
		1610	//$FALL-THROUGH$
		1611	case 1:
		1612	getPackage().isViewedAsDeprecated(); // initialize annotations
		1613	this.nullnessDefaultInitialized = 2;
		1614	}
		1615	AbstractMethodDeclaration methodDecl = method.sourceMethod();
		1616	if (methodDecl != null) {
		1617	if (method.parameters != Binding.NO_PARAMETERS)
		1618	methodDecl.bindArguments();
		1619	TypeBinding annotationBinding = findDefaultNullness(method, methodDecl.scope.environment());
		1620	if (annotationBinding != null && annotationBinding.id == TypeIds.T_ConfiguredAnnotationNonNull)
		1621	method.fillInDefaultNonNullness(annotationBinding);
		1622	}
		1623	}
		1624	private void evaluateNullAnnotations(long annotationTagBits) {
		1625	if (this.nullnessDefaultInitialized > 0)
		1626	return;
		1627	this.nullnessDefaultInitialized = 1;
		1628	// transfer nullness info from tagBits to this.nullnessDefaultAnnotation
		1629	TypeBinding defaultAnnotation = getPackage().environment
		1630	.getNullAnnotationBindingFromDefault(annotationTagBits, false/resolve/);
		1631	if (defaultAnnotation != null) {
		1632	if (CharOperation.equals(this.sourceName, TypeConstants.PACKAGE_INFO_NAME)) {
		1633	getPackage().nullnessDefaultAnnotation = defaultAnnotation;
		1634	} else {
		1635	this.nullnessDefaultAnnotation = defaultAnnotation;
		1636	}
		1637	}
		1638	}
		1639	private TypeBinding getNullnessDefaultAnnotation() {
		1640	if (this.nullnessDefaultAnnotation instanceof UnresolvedReferenceBinding)
		1641	return this.nullnessDefaultAnnotation =
		1642	BinaryTypeBinding.resolveType(this.nullnessDefaultAnnotation, getPackage().environment, false);
		1643	return this.nullnessDefaultAnnotation;
		1644	}
		1645	/**
		1646	* Answer the nullness default applicable at the given method binding.
		1647	* Possible values:<ul>
		1648	* <li>the type binding for @NonNulByDefault</li>
		1649	* <li>the synthetic type {@link ReferenceBinding#NULL_UNSPECIFIED} if a default from outer scope has been canceled</li>
		1650	* <li>null if no default has been defined</li>
		1651	* </ul>
		1652	*/
		1653	private TypeBinding findDefaultNullness(MethodBinding methodBinding, LookupEnvironment environment) {
		1654	// find the applicable default inside->out:
		1655
		1656	// method
		1657	TypeBinding annotationBinding = environment.getNullAnnotationBindingFromDefault(methodBinding.tagBits, true/resolve/);
		1658	if (annotationBinding != null)
		1659	return annotationBinding;
		1660
		1661	// type
		1662	ReferenceBinding type = methodBinding.declaringClass;
		1663	ReferenceBinding currentType = type;
		1664	while (currentType instanceof SourceTypeBinding) {
		1665	annotationBinding = ((SourceTypeBinding) currentType).getNullnessDefaultAnnotation();
		1666	if (annotationBinding != null)
		1667	return annotationBinding;
		1668	currentType = currentType.enclosingType();
		1669	}
1670
1671	// package
1672	annotationBinding = type.getPackage().getNullnessDefaultAnnotation();
1673	if (annotationBinding != null)
1674	return annotationBinding;
1675
1676	// global
1677	long defaultNullness = environment.globalOptions.defaultNonNullness;
1678	if (defaultNullness != 0) {
1679	annotationBinding = environment.getNullAnnotationBinding(defaultNullness, true/resolve/);
1680	if (annotationBinding != null)
1681	return annotationBinding;
1682
1683	// on this branch default was not defined using an annotation, thus annotation type can still be missing
1684	if (defaultNullness == TagBits.AnnotationNonNull)
1685	this.scope.problemReporter().missingNullAnnotationType(environment.getNonNullAnnotationName());
1686	else if (defaultNullness == TagBits.AnnotationNullable)
1687	this.scope.problemReporter().missingNullAnnotationType(environment.getNullableAnnotationName());
1688	else
1689	this.scope.problemReporter().abortDueToInternalError("Illegal default nullness value: "+defaultNullness); //$NON-NLS-1$
1690	// reset default to avoid duplicate errors:
1691	environment.globalOptions.defaultNonNullness = 0;
1692	}
1693	return null;
1694	}
1695
1599	public AnnotationHolder retrieveAnnotationHolder(Binding binding, boolean forceInitialization) {	1696	public AnnotationHolder retrieveAnnotationHolder(Binding binding, boolean forceInitialization) {
1600	if (forceInitialization)	1697	if (forceInitialization)
1601	binding.getAnnotationTagBits(); // ensure annotations are up to date	1698	binding.getAnnotationTagBits(); // ensure annotations are up to date

Lines 132-137 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TagBits.java (-3 / +15 lines)
132	long AnnotationPreDestroy = ASTNode.Bit54L;	132	long AnnotationPreDestroy = ASTNode.Bit54L;
133	/** @since 3.8 */	133	/** @since 3.8 */
134	long AnnotationPostConstruct = ASTNode.Bit55L;	134	long AnnotationPostConstruct = ASTNode.Bit55L;
		135	/** @since 3.8 null annotation for MethodBinding or LocalVariableBinding (argument): */
		136	long AnnotationNullable = ASTNode.Bit56L;
		137	/** @since 3.8 null annotation for MethodBinding or LocalVariableBinding (argument): */
		138	long AnnotationNonNull = ASTNode.Bit57L;
		139	/** @since 3.8 null-default annotation for PackageBinding or TypeBinding or MethodBinding: */
		140	long AnnotationNonNullByDefault = ASTNode.Bit58L;
		141	/** @since 3.8 canceling null-default annotation for PackageBinding or TypeBinding or MethodBinding: */
		142	long AnnotationNullUnspecifiedByDefault = ASTNode.Bit59L;
135		143
136	long AllStandardAnnotationsMask =	144	long AllStandardAnnotationsMask =
137	AnnotationTargetMASK	145	AnnotationTargetMASK
Lines 144-153 Link Here
144	\| AnnotationSafeVarargs	152	\| AnnotationSafeVarargs
145	\| AnnotationPolymorphicSignature	153	\| AnnotationPolymorphicSignature
146	\| AnnotationPostConstruct	154	\| AnnotationPostConstruct
147	\| AnnotationPreDestroy;	155	\| AnnotationPreDestroy
		156	\| AnnotationNullable
		157	\| AnnotationNonNull
		158	\| AnnotationNonNullByDefault
		159	\| AnnotationNullUnspecifiedByDefault;
148		160
149	long DefaultValueResolved = ASTNode.Bit56L;	161	long DefaultValueResolved = ASTNode.Bit60L;
150		162
151	// set when type contains non-private constructor(s)	163	// set when type contains non-private constructor(s)
152	long HasNonPrivateConstructor = ASTNode.Bit57L;	164	long HasNonPrivateConstructor = ASTNode.Bit61L;
153	}	165	}

Lines 104-109 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeIds.java (+5 lines)
104	final int T_JavaxAnnotationPostConstruct = 63;	104	final int T_JavaxAnnotationPostConstruct = 63;
105		105
106	final int T_JavaxAnnotationPreDestroy = 64;	106	final int T_JavaxAnnotationPreDestroy = 64;
		107
		108	// new in 3.8 for null annotations:
		109	final int T_ConfiguredAnnotationNullable = 65;
		110	final int T_ConfiguredAnnotationNonNull = 66;
		111	final int T_ConfiguredAnnotationNonNullByDefault = 67;
107		112
108	final int NoId = Integer.MAX_VALUE;	113	final int NoId = Integer.MAX_VALUE;
109		114




import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;

			return CompilerOptions.NullReference;

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

		case IProblem.RedundantLocalVariableNullAssignment:

		case IProblem.NonNullLocalVariableComparisonYieldsFalse:
		case IProblem.NullLocalVariableComparisonYieldsFalse:
		case IProblem.NullLocalVariableInstanceofYieldsFalse:
		case IProblem.RedundantNullCheckOnNonNullMessageSend:
			return CompilerOptions.RedundantNullCheck;

		case IProblem.RequiredNonNullButProvidedNull:
		case IProblem.IllegalReturnNullityRedefinition:
		case IProblem.IllegalRedefinitionToNonNullParameter:
		case IProblem.IllegalDefinitionToNonNullParameter:
		case IProblem.ParameterLackingNonNullAnnotation:
		case IProblem.ParameterLackingNullableAnnotation:
		case IProblem.CannotImplementIncompatibleNullness:
			return CompilerOptions.NullSpecViolation;
		
		case IProblem.RequiredNonNullButProvidedPotentialNull:
			return CompilerOptions.PotentialNullSpecViolation;
		case IProblem.RequiredNonNullButProvidedUnknown:
			return CompilerOptions.NullSpecInsufficientInfo;
		case IProblem.RedundantNullAnnotation:
			return CompilerOptions.RedundantNullAnnotation;

		case IProblem.BoxingConversion :
		case IProblem.UnboxingConversion :

			case CompilerOptions.DiscouragedReference :
				return CategorizedProblem.CAT_RESTRICTION;
			
			case CompilerOptions.NullSpecViolation :
			case CompilerOptions.PotentialNullSpecViolation :
			case CompilerOptions.NullSpecInsufficientInfo :
				return CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM;
			case CompilerOptions.RedundantNullAnnotation :
				return CategorizedProblem.CAT_UNNECESSARY_CODE;

			default:
				break categorizeOnIrritant;
		}

	switch (problemID) {
		case IProblem.IsClassPathCorrect :
		case IProblem.CorruptedSignature :
		case IProblem.MissingNullAnnotationType :
		case IProblem.NullAnnotationNameMustBeQualified :
			return CategorizedProblem.CAT_BUILDPATH;

		default :

		trackVar.sourceStart,
		trackVar.sourceEnd);	
}

public void nullityMismatch(Expression expression, TypeBinding requiredType, int nullStatus, char[][] annotationName) {
	int problemId = IProblem.RequiredNonNullButProvidedUnknown;
	if ((nullStatus & FlowInfo.NULL) != 0)
		problemId = IProblem.RequiredNonNullButProvidedNull;
	if ((nullStatus & FlowInfo.POTENTIALLY_NULL) != 0)
		problemId = IProblem.RequiredNonNullButProvidedPotentialNull;
	String[] arguments = new String[] { 
			String.valueOf(CharOperation.concatWith(annotationName, '.')),
			String.valueOf(requiredType.readableName())
	};
	String[] argumentsShort = new String[] { 
			String.valueOf(annotationName[annotationName.length-1]),
			String.valueOf(requiredType.shortReadableName())
	};
	this.handle(
		problemId,
		arguments,
		argumentsShort,
		expression.sourceStart,
		expression.sourceEnd);
}
public void illegalRedefinitionToNonNullParameter(Argument argument, ReferenceBinding declaringClass, char[][] inheritedAnnotationName) {
	int sourceStart = argument.type.sourceStart;
	if (argument.annotations != null) {
		for (int i=0; i<argument.annotations.length; i++) {
			Annotation annotation = argument.annotations[i];
			if (   annotation.resolvedType.id == TypeIds.T_ConfiguredAnnotationNullable
				|| annotation.resolvedType.id == TypeIds.T_ConfiguredAnnotationNonNull) 
			{
				sourceStart = annotation.sourceStart;
				break;
			}
		}
	}
	if (inheritedAnnotationName == null) {
		this.handle(
			IProblem.IllegalDefinitionToNonNullParameter, 
			new String[] { new String(argument.name), new String(declaringClass.readableName()) },
			new String[] { new String(argument.name), new String(declaringClass.shortReadableName()) },
			sourceStart,
			argument.type.sourceEnd);
		
	} else {
		this.handle(
			IProblem.IllegalRedefinitionToNonNullParameter, 
			new String[] { new String(argument.name), new String(declaringClass.readableName()), CharOperation.toString(inheritedAnnotationName)},
			new String[] { new String(argument.name), new String(declaringClass.shortReadableName()), new String(inheritedAnnotationName[inheritedAnnotationName.length-1])},
			sourceStart,
			argument.type.sourceEnd);
	}
}
public void parameterLackingNonNullAnnotation(Argument argument, ReferenceBinding declaringClass, boolean needNonNull, char[][] inheritedAnnotationName) {
	this.handle(
		needNonNull ? IProblem.ParameterLackingNonNullAnnotation : IProblem.ParameterLackingNullableAnnotation, 
		new String[] { new String(argument.name), new String(declaringClass.readableName()), CharOperation.toString(inheritedAnnotationName)},
		new String[] { new String(argument.name), new String(declaringClass.shortReadableName()), new String(inheritedAnnotationName[inheritedAnnotationName.length-1])},
		argument.type.sourceStart,
		argument.type.sourceEnd);
}
public void illegalReturnRedefinition(AbstractMethodDeclaration abstractMethodDecl,
									  MethodBinding inheritedMethod, char[][] nonNullAnnotationName) 
{
	MethodDeclaration methodDecl = (MethodDeclaration) abstractMethodDecl;
	StringBuffer methodSignature = new StringBuffer();
	methodSignature
		.append(inheritedMethod.declaringClass.readableName())
		.append('.')
		.append(inheritedMethod.readableName());

	StringBuffer shortSignature = new StringBuffer();
	shortSignature
		.append(inheritedMethod.declaringClass.shortReadableName())
		.append('.')
		.append(inheritedMethod.shortReadableName());
	int sourceStart = methodDecl.returnType.sourceStart;
	Annotation[] annotations = methodDecl.annotations;
	if (annotations != null) {
		for (int i=0; i<annotations.length; i++) {
			if (annotations[i].resolvedType.id == TypeIds.T_ConfiguredAnnotationNullable) {
				sourceStart = annotations[i].sourceStart;
				break;
			}
		}
	}
	this.handle(
		IProblem.IllegalReturnNullityRedefinition, 
		new String[] { methodSignature.toString(), CharOperation.toString(nonNullAnnotationName)},
		new String[] { shortSignature.toString(), new String(nonNullAnnotationName[nonNullAnnotationName.length-1])},
		sourceStart, 
		methodDecl.returnType.sourceEnd);
}
public void messageSendPotentialNullReference(MethodBinding method, ASTNode location) {
	String[] arguments = new String[] {new String(method.readableName())};
	this.handle(
		IProblem.PotentialNullMessageSendReference,
		arguments,
		arguments,
		location.sourceStart,
		location.sourceEnd);
}
public void messageSendRedundantCheckOnNonNull(MethodBinding method, ASTNode location) {
	String[] arguments = new String[] {new String(method.readableName())  };
	this.handle(
		IProblem.RedundantNullCheckOnNonNullMessageSend,
		arguments,
		arguments,
		location.sourceStart,
		location.sourceEnd);
}

public void missingNullAnnotationType(char[][] nullAnnotationName) {
	String[] args = { new String(CharOperation.concatWith(nullAnnotationName, '.')) };
	this.handle(IProblem.MissingNullAnnotationType, args, args, 0, 0);	
}

public void cannotImplementIncompatibleNullness(MethodBinding currentMethod, MethodBinding inheritedMethod) {
	int sourceStart = 0, sourceEnd = 0;
	if (this.referenceContext instanceof TypeDeclaration) {
		sourceStart = ((TypeDeclaration) this.referenceContext).sourceStart;
		sourceEnd =   ((TypeDeclaration) this.referenceContext).sourceEnd;
	}
	String[] problemArguments = {
			new String(currentMethod.readableName()),
			new String(currentMethod.declaringClass.readableName()),
			new String(inheritedMethod.declaringClass.readableName())
		};
	String[] messageArguments = {
			new String(currentMethod.shortReadableName()),
			new String(currentMethod.declaringClass.shortReadableName()),
			new String(inheritedMethod.declaringClass.shortReadableName())
		};
	this.handle(
			IProblem.CannotImplementIncompatibleNullness,
			problemArguments,
			messageArguments,
			sourceStart,
			sourceEnd);
}

public void nullAnnotationNameMustBeQualified(char[][] typeName) {
	String[] name = {new String(typeName[0])};
	this.handle(IProblem.NullAnnotationNameMustBeQualified, name, name, 0, 0);
}

public void nullAnnotationIsRedundant(AbstractMethodDeclaration sourceMethod, int i) {
	int sourceStart, sourceEnd;
	if (i == -1) {
		org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration decl = sourceMethod;
		org.eclipse.jdt.internal.compiler.ast.MethodDeclaration methodDecl = (org.eclipse.jdt.internal.compiler.ast.MethodDeclaration) decl;
		sourceStart = methodDecl.returnType.sourceStart;
		if (methodDecl.annotations != null) {
			// should have a @NonNull annotation, search for it:
			for (int j=0; j<methodDecl.annotations.length; j++) {
				if (methodDecl.annotations[j].resolvedType.id == TypeIds.T_ConfiguredAnnotationNonNull) {
					sourceStart = methodDecl.annotations[j].sourceStart;
					break;
				}
			}
		}
		sourceEnd = methodDecl.returnType.sourceEnd;
	} else {
		Argument arg = sourceMethod.arguments[i];
		sourceStart = arg.declarationSourceStart;
		sourceEnd = arg.sourceEnd;
	}
	this.handle(IProblem.RedundantNullAnnotation, ProblemHandler.NoArgument, ProblemHandler.NoArgument, sourceStart, sourceEnd);
}
}




889 = Resource ''{0}'' should be managed by try-with-resource
890 = Cannot switch on an enum value for source level below 1.5. Only convertible int values are permitted

### NULL ANNOTATIONS
910 = Type mismatch: required '@{0} {1}' but the provided value is null
911 = Type mismatch: required '@{0} {1}' but the provided value can be null
912 = Potential type mismatch: required '@{0} {1}' but nullness of the provided value is unknown
913 = Buildpath problem: the type {0} which is configured as a null annotation type cannot be resolved
914 = Cannot use the unqualified name ''{0}'' as an annotation name for null specification
915 = The return type is incompatible with the @{1} return from {0}
916 = Illegal redefinition of parameter {0}, inherited method from {1} declares this parameter as @{2}
917 = Illegal redefinition of parameter {0}, inherited method from {1} does not constrain this parameter
918 = Missing null annotation: inherited method from {1} declares this parameter as @{2}
919 = Missing null annotation: inherited method from {1} declares this parameter as @{2}
920 = Potential null pointer access: The method {0} may return null
921 = Redundant null check: The method {0} cannot return null
922 = The method {0} from class {1} cannot implement the corresponding method from type {2} due to incompatible nullness constraints
923 = The nullness annotation is redundant with a default that applies to this location

### ELABORATIONS
## Access restrictions
78592 = The type {1} is not accessible due to restriction on classpath entry {0}

Return to bug 186342

Lines 380-385 Link Here

(-)a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (+14 lines)
380	expectedProblemAttributes.put("CannotDefineStaticInitializerInLocalType", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	380	expectedProblemAttributes.put("CannotDefineStaticInitializerInLocalType", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
381	expectedProblemAttributes.put("CannotExtendEnum", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	381	expectedProblemAttributes.put("CannotExtendEnum", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
382	expectedProblemAttributes.put("CannotHideAnInstanceMethodWithAStaticMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	382	expectedProblemAttributes.put("CannotHideAnInstanceMethodWithAStaticMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		383	expectedProblemAttributes.put("CannotImplementIncompatibleNullness", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
383	expectedProblemAttributes.put("CannotImportPackage", new ProblemAttributes(CategorizedProblem.CAT_IMPORT));	384	expectedProblemAttributes.put("CannotImportPackage", new ProblemAttributes(CategorizedProblem.CAT_IMPORT));
384	expectedProblemAttributes.put("CannotInferElidedTypes", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	385	expectedProblemAttributes.put("CannotInferElidedTypes", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
385	expectedProblemAttributes.put("CannotInvokeSuperConstructorInEnum", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	386	expectedProblemAttributes.put("CannotInvokeSuperConstructorInEnum", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
Lines 472-477 Link Here
472	expectedProblemAttributes.put("IllegalAccessFromTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	473	expectedProblemAttributes.put("IllegalAccessFromTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
473	expectedProblemAttributes.put("IllegalCast", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	474	expectedProblemAttributes.put("IllegalCast", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
474	expectedProblemAttributes.put("IllegalClassLiteralForTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	475	expectedProblemAttributes.put("IllegalClassLiteralForTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		476	expectedProblemAttributes.put("IllegalDefinitionToNonNullParameter", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
475	expectedProblemAttributes.put("IllegalDimension", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	477	expectedProblemAttributes.put("IllegalDimension", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
476	expectedProblemAttributes.put("IllegalEnclosingInstanceSpecification", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	478	expectedProblemAttributes.put("IllegalEnclosingInstanceSpecification", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
477	expectedProblemAttributes.put("IllegalExtendedDimensions", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	479	expectedProblemAttributes.put("IllegalExtendedDimensions", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
Lines 506-511 Link Here
506	expectedProblemAttributes.put("IllegalPrimitiveOrArrayTypeForEnclosingInstance", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	508	expectedProblemAttributes.put("IllegalPrimitiveOrArrayTypeForEnclosingInstance", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
507	expectedProblemAttributes.put("IllegalQualifiedEnumConstantLabel", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	509	expectedProblemAttributes.put("IllegalQualifiedEnumConstantLabel", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
508	expectedProblemAttributes.put("IllegalQualifiedParameterizedTypeAllocation", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	510	expectedProblemAttributes.put("IllegalQualifiedParameterizedTypeAllocation", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		511	expectedProblemAttributes.put("IllegalReturnNullityRedefinition", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		512	expectedProblemAttributes.put("IllegalRedefinitionToNonNullParameter", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
509	expectedProblemAttributes.put("IllegalStaticModifierForMemberType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	513	expectedProblemAttributes.put("IllegalStaticModifierForMemberType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
510	expectedProblemAttributes.put("IllegalTypeVariableSuperReference", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	514	expectedProblemAttributes.put("IllegalTypeVariableSuperReference", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
511	expectedProblemAttributes.put("IllegalUnderscorePosition", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	515	expectedProblemAttributes.put("IllegalUnderscorePosition", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
Lines 690-695 Link Here
690	expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	694	expectedProblemAttributes.put("MissingEnclosingInstanceForConstructorCall", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
691	expectedProblemAttributes.put("MissingEnumConstantCase", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	695	expectedProblemAttributes.put("MissingEnumConstantCase", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
692	expectedProblemAttributes.put("MissingOverrideAnnotation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	696	expectedProblemAttributes.put("MissingOverrideAnnotation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		697	expectedProblemAttributes.put("MissingNullAnnotationType", new ProblemAttributes(CategorizedProblem.CAT_BUILDPATH));
693	expectedProblemAttributes.put("MissingOverrideAnnotationForInterfaceMethodImplementation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	698	expectedProblemAttributes.put("MissingOverrideAnnotationForInterfaceMethodImplementation", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
694	expectedProblemAttributes.put("MissingReturnType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	699	expectedProblemAttributes.put("MissingReturnType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
695	expectedProblemAttributes.put("MissingSemiColon", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	700	expectedProblemAttributes.put("MissingSemiColon", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
Lines 729-734 Link Here
729	expectedProblemAttributes.put("NotVisibleField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	734	expectedProblemAttributes.put("NotVisibleField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
730	expectedProblemAttributes.put("NotVisibleMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	735	expectedProblemAttributes.put("NotVisibleMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
731	expectedProblemAttributes.put("NotVisibleType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	736	expectedProblemAttributes.put("NotVisibleType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		737	expectedProblemAttributes.put("NullAnnotationNameMustBeQualified", new ProblemAttributes(CategorizedProblem.CAT_BUILDPATH));
732	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	738	expectedProblemAttributes.put("NullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
733	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	739	expectedProblemAttributes.put("NullLocalVariableInstanceofYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
734	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	740	expectedProblemAttributes.put("NullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
Lines 745-750 Link Here
745	expectedProblemAttributes.put("PackageCollidesWithType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	751	expectedProblemAttributes.put("PackageCollidesWithType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
746	expectedProblemAttributes.put("PackageIsNotExpectedPackage", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	752	expectedProblemAttributes.put("PackageIsNotExpectedPackage", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
747	expectedProblemAttributes.put("ParameterAssignment", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	753	expectedProblemAttributes.put("ParameterAssignment", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
		754	expectedProblemAttributes.put("ParameterLackingNonNullAnnotation", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		755	expectedProblemAttributes.put("ParameterLackingNullableAnnotation", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
748	expectedProblemAttributes.put("ParameterMismatch", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	756	expectedProblemAttributes.put("ParameterMismatch", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
749	expectedProblemAttributes.put("ParameterizedConstructorArgumentTypeMismatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	757	expectedProblemAttributes.put("ParameterizedConstructorArgumentTypeMismatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
750	expectedProblemAttributes.put("ParameterizedMethodArgumentTypeMismatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	758	expectedProblemAttributes.put("ParameterizedMethodArgumentTypeMismatch", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
Lines 771-776 Link Here
771	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	779	expectedProblemAttributes.put("PotentiallyUnclosedCloseable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
772	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	780	expectedProblemAttributes.put("PotentiallyUnclosedCloseableAtExit", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
773	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	781	expectedProblemAttributes.put("PotentialNullLocalVariableReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		782	expectedProblemAttributes.put("PotentialNullMessageSendReference", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
774	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	783	expectedProblemAttributes.put("PublicClassMustMatchFileName", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
775	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	784	expectedProblemAttributes.put("RawMemberTypeCannotBeParameterized", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
776	expectedProblemAttributes.put("RawTypeReference", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));	785	expectedProblemAttributes.put("RawTypeReference", new ProblemAttributes(CategorizedProblem.CAT_UNCHECKED_RAW));
Lines 779-788 Link Here
779	expectedProblemAttributes.put("RedefinedLocal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	788	expectedProblemAttributes.put("RedefinedLocal", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
780	expectedProblemAttributes.put("RedundantSpecificationOfTypeArguments", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));	789	expectedProblemAttributes.put("RedundantSpecificationOfTypeArguments", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
781	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	790	expectedProblemAttributes.put("RedundantLocalVariableNullAssignment", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		791	expectedProblemAttributes.put("RedundantNullAnnotation", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
782	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	792	expectedProblemAttributes.put("RedundantNullCheckOnNonNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		793	expectedProblemAttributes.put("RedundantNullCheckOnNonNullMessageSend", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
783	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	794	expectedProblemAttributes.put("RedundantNullCheckOnNullLocalVariable", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
784	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));	795	expectedProblemAttributes.put("RedundantSuperinterface", new ProblemAttributes(CategorizedProblem.CAT_UNNECESSARY_CODE));
785	expectedProblemAttributes.put("ReferenceToForwardField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	796	expectedProblemAttributes.put("ReferenceToForwardField", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
		797	expectedProblemAttributes.put("RequiredNonNullButProvidedNull", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		798	expectedProblemAttributes.put("RequiredNonNullButProvidedPotentialNull", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		799	expectedProblemAttributes.put("RequiredNonNullButProvidedUnknown", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
786	expectedProblemAttributes.put("ReferenceToForwardTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	800	expectedProblemAttributes.put("ReferenceToForwardTypeVariable", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
787	expectedProblemAttributes.put("ResourceHasToImplementAutoCloseable", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	801	expectedProblemAttributes.put("ResourceHasToImplementAutoCloseable", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
788	expectedProblemAttributes.put("ReturnTypeAmbiguous", DEPRECATED);	802	expectedProblemAttributes.put("ReturnTypeAmbiguous", DEPRECATED);

Lines 1412-1417 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/core/compiler/IProblem.java (+32 lines)
1412	/** @since 3.8 */	1412	/** @since 3.8 */
1413	int SwitchOnEnumNotBelow15 = TypeRelated + 890; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=360317	1413	int SwitchOnEnumNotBelow15 = TypeRelated + 890; // https://bugs.eclipse.org/bugs/show_bug.cgi?id=360317
1414	/**	1414	/**
		1415	* Errors/warnings from annotation based null analysis
		1416	*/
		1417	/** @since 3.8 */
		1418	int RequiredNonNullButProvidedNull = TypeRelated + 910;
		1419	/** @since 3.8 */
		1420	int RequiredNonNullButProvidedPotentialNull = TypeRelated + 911;
		1421	/** @since 3.8 */
		1422	int RequiredNonNullButProvidedUnknown = TypeRelated + 912;
		1423	/** @since 3.8 */
		1424	int MissingNullAnnotationType = ImportRelated + 913;
		1425	/** @since 3.8 */
		1426	int NullAnnotationNameMustBeQualified = Internal + 914;
		1427	/** @since 3.8 */
		1428	int IllegalReturnNullityRedefinition = MethodRelated + 915;
		1429	/** @since 3.8 */
		1430	int IllegalRedefinitionToNonNullParameter = MethodRelated + 916;
		1431	/** @since 3.8 */
		1432	int IllegalDefinitionToNonNullParameter = MethodRelated + 917;
		1433	/** @since 3.8 */
		1434	int ParameterLackingNonNullAnnotation = MethodRelated + 918;
		1435	/** @since 3.8 */
		1436	int ParameterLackingNullableAnnotation = MethodRelated + 919;
		1437	/** @since 3.8 */
		1438	int PotentialNullMessageSendReference = Internal + 920;
		1439	/** @since 3.8 */
		1440	int RedundantNullCheckOnNonNullMessageSend = Internal + 921;
		1441	/** @since 3.8 */
		1442	int CannotImplementIncompatibleNullness = Internal + 922;
		1443	/** @since 3.8 */
		1444	int RedundantNullAnnotation = MethodRelated + 923;
		1445
		1446	/**
1415	* External problems -- These are problems defined by other plugins	1447	* External problems -- These are problems defined by other plugins
1416	*/	1448	*/
1417		1449

Lines 173-178 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java (+16 lines)
173	case TypeIds.T_JavaxAnnotationPreDestroy :	173	case TypeIds.T_JavaxAnnotationPreDestroy :
174	tagBits \|= TagBits.AnnotationPreDestroy;	174	tagBits \|= TagBits.AnnotationPreDestroy;
175	break;	175	break;
		176	case TypeIds.T_ConfiguredAnnotationNullable :
		177	tagBits \|= TagBits.AnnotationNullable;
		178	break;
		179	case TypeIds.T_ConfiguredAnnotationNonNull :
		180	tagBits \|= TagBits.AnnotationNonNull;
		181	break;
		182	case TypeIds.T_ConfiguredAnnotationNonNullByDefault :
		183	if (valueAttribute != null
		184	&& valueAttribute.value instanceof FalseLiteral)
		185	{
		186	// parameter 'false' means: this annotation cancels any defaults
		187	tagBits \|= TagBits.AnnotationNullUnspecifiedByDefault;
		188	break;
		189	}
		190	tagBits \|= TagBits.AnnotationNonNullByDefault;
		191	break;
176	}	192	}
177	return tagBits;	193	return tagBits;
178	}	194	}

Lines 113-121 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java (-1 / +11 lines)
113	}	113	}
114	}	114	}
115		115
116	// tag parameters as being set
117	if (this.arguments != null) {	116	if (this.arguments != null) {
118	for (int i = 0, count = this.arguments.length; i < count; i++) {	117	for (int i = 0, count = this.arguments.length; i < count; i++) {
		118	if (this.binding.parameterNonNullness != null) {
		119	// leverage null-info from parameter annotations:
		120	Boolean nonNullNess = this.binding.parameterNonNullness[i];
		121	if (nonNullNess != null) {
		122	if (nonNullNess.booleanValue())
		123	flowInfo.markAsDefinitelyNonNull(this.arguments[i].binding);
		124	else
		125	flowInfo.markPotentiallyNullBit(this.arguments[i].binding);
		126	}
		127	}
		128	// tag parameters as being set
119	flowInfo.markAsDefinitelyAssigned(this.arguments[i].binding);	129	flowInfo.markAsDefinitelyAssigned(this.arguments[i].binding);
120	}	130	}
121	}	131	}

Lines 79-87 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java (-1 / +11 lines)
79	this.scope,	79	this.scope,
80	FlowInfo.DEAD_END);	80	FlowInfo.DEAD_END);
81		81
82	// tag parameters as being set
83	if (this.arguments != null) {	82	if (this.arguments != null) {
84	for (int i = 0, count = this.arguments.length; i < count; i++) {	83	for (int i = 0, count = this.arguments.length; i < count; i++) {
		84	if (this.binding.parameterNonNullness != null) {
		85	// leverage null-info from parameter annotations:
		86	Boolean nonNullNess = this.binding.parameterNonNullness[i];
		87	if (nonNullNess != null) {
		88	if (nonNullNess.booleanValue())
		89	flowInfo.markAsDefinitelyNonNull(this.arguments[i].binding);
		90	else
		91	flowInfo.markPotentiallyNullBit(this.arguments[i].binding);
		92	}
		93	}
		94	// tag parameters as being set:
85	flowInfo.markAsDefinitelyAssigned(this.arguments[i].binding);	95	flowInfo.markAsDefinitelyAssigned(this.arguments[i].binding);
86	// if this method uses a type parameter declared by the declaring class,	96	// if this method uses a type parameter declared by the declaring class,
87	// it can't be static. https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682	97	// it can't be static. https://bugs.eclipse.org/bugs/show_bug.cgi?id=318682

Lines 57-64 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/Statement.java (-2 / +29 lines)
57	public static final int COMPLAINED_FAKE_REACHABLE = 1;	57	public static final int COMPLAINED_FAKE_REACHABLE = 1;
58	public static final int COMPLAINED_UNREACHABLE = 2;	58	public static final int COMPLAINED_UNREACHABLE = 2;
59		59
60	/** Empty hook for checking null status against declaration using null annotations, once this will be supported. */	60
61	protected int checkAgainstNullAnnotation(BlockScope currentScope, LocalVariableBinding local, int nullStatus) {	61	/** Analysing arguments of MessageSend, ExplicitConstructorCall, AllocationExpression. */
		62	protected void analyseArguments(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo, MethodBinding methodBinding, Expression[] arguments)
		63	{
		64	// compare actual null-status against parameter annotations of the called method:
		65	if (arguments != null && methodBinding.parameterNonNullness != null) {
		66	for (int i = 0; i < arguments.length; i++) {
		67	if (methodBinding.parameterNonNullness[i] == Boolean.TRUE) {
		68	TypeBinding expectedType = methodBinding.parameters[i];
		69	Expression argument = arguments[i];
		70	int nullStatus = argument.nullStatus(flowInfo); // slight loss of precision: should also use the null info from the receiver.
		71	if (nullStatus != FlowInfo.NON_NULL) // if required non-null is not provided
		72	flowContext.recordNullityMismatch(currentScope, argument, nullStatus, expectedType);
		73	}
		74	}
		75	}
		76	}
		77
		78	/** Check null-ness of 'local' against a possible null annotation */
		79	protected int checkAssignmentAgainstNullAnnotation(BlockScope currentScope, FlowContext flowContext,
		80	LocalVariableBinding local, int nullStatus, Expression expression)
		81	{
		82	if ( local != null
		83	&& (local.tagBits & TagBits.AnnotationNonNull) != 0
		84	&& nullStatus != FlowInfo.NON_NULL)
		85	{
		86	flowContext.recordNullityMismatch(currentScope, expression, nullStatus, local.type);
		87	nullStatus=FlowInfo.NON_NULL;
		88	}
62	return nullStatus;	89	return nullStatus;
63	}	90	}
64		91

Lines 653-658 Link Here

(-)a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+16 lines)
653	889 = Resource ''{0}'' should be managed by try-with-resource	653	889 = Resource ''{0}'' should be managed by try-with-resource
654	890 = Cannot switch on an enum value for source level below 1.5. Only convertible int values are permitted	654	890 = Cannot switch on an enum value for source level below 1.5. Only convertible int values are permitted
655		655
		656	### NULL ANNOTATIONS
		657	910 = Type mismatch: required '@{0} {1}' but the provided value is null
		658	911 = Type mismatch: required '@{0} {1}' but the provided value can be null
		659	912 = Potential type mismatch: required '@{0} {1}' but nullness of the provided value is unknown
		660	913 = Buildpath problem: the type {0} which is configured as a null annotation type cannot be resolved
		661	914 = Cannot use the unqualified name ''{0}'' as an annotation name for null specification
		662	915 = The return type is incompatible with the @{1} return from {0}
		663	916 = Illegal redefinition of parameter {0}, inherited method from {1} declares this parameter as @{2}
		664	917 = Illegal redefinition of parameter {0}, inherited method from {1} does not constrain this parameter
		665	918 = Missing null annotation: inherited method from {1} declares this parameter as @{2}
		666	919 = Missing null annotation: inherited method from {1} declares this parameter as @{2}
		667	920 = Potential null pointer access: The method {0} may return null
		668	921 = Redundant null check: The method {0} cannot return null
		669	922 = The method {0} from class {1} cannot implement the corresponding method from type {2} due to incompatible nullness constraints
		670	923 = The nullness annotation is redundant with a default that applies to this location
		671
656	### ELABORATIONS	672	### ELABORATIONS
657	## Access restrictions	673	## Access restrictions
658	78592 = The type {1} is not accessible due to restriction on classpath entry {0}	674	78592 = The type {1} is not accessible due to restriction on classpath entry {0}