Attachment #185507 for bug #186342

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

and this patch




 *     Benjamin Muskalla - Contribution for bug 239066
 *     Stephan Herrmann  - Contribution for bug 236385
 *     Stephan Herrmann  - Contribution for bug 295551
 *     Stephan Herrmann  - Contribution for bug 186342
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.batch;


					mode = INSIDE_WARNINGS_PROPERTIES;
					continue;
				}
				if (currentArg.startsWith("-nullAnnotations:")) { //$NON-NLS-1$
					StringTokenizer tokenizer =
						new StringTokenizer(currentArg.substring("-nullAnnotations:".length()), ","); //$NON-NLS-1$ //$NON-NLS-2$
					while (tokenizer.hasMoreTokens()) {
						String token = tokenizer.nextToken();
						if (token.startsWith("nullable=")) { //$NON-NLS-1$
							this.options.put(CompilerOptions.OPTION_NullableAnnotationName, token.substring("nullable=".length())); //$NON-NLS-1$
						} else if (token.startsWith("nonnull=")) { //$NON-NLS-1$
							this.options.put(CompilerOptions.OPTION_NonNullAnnotationName, token.substring("nonnull=".length())); //$NON-NLS-1$
						} else if (token.equals("emulate")) { //$NON-NLS-1$
							this.options.put(CompilerOptions.OPTION_EmulateNullAnnotationTypes, CompilerOptions.ENABLED);
						} else if (token.equals("import")) { //$NON-NLS-1$
							this.options.put(CompilerOptions.OPTION_DefaultImportNullAnnotationTypes, CompilerOptions.ENABLED);
						} else {
							throw new IllegalArgumentException(
								this.bind("configure.unrecognized.nullannotation.option", token)); //$NON-NLS-1$
						}
					}
					mode = DEFAULT;
					continue;
				}
				break;
			case INSIDE_TARGET :
				if (this.didSpecifyTarget) {




# Contributors:
#     IBM Corporation - initial API and implementation
#		Benjamin Muskalla - Contribution for bug 239066
#       Stephan Herrmann  - Contribution for bug 186342
###############################################################################
### JavaBatchCompiler messages.



## configure.directoryNotExist = directory does not exist: {0}
configure.unrecognizedOption = Unrecognized option : {0}
configure.unrecognized.nullannotation.option = Unrecognized sub-option of -nullAnnotations: {0},\nlegal values are 'nullable=..', 'nonnull=..', 'emulate' and 'import'
configure.noClasspath = no classpath defined, using default directory instead
configure.incorrectClasspath = incorrect classpath: {0}
configure.invalidexpansionargumentname = expansion argument file {0} does not exist or cannot be read

\    -classNames <className1[,className2,...]>\n\
\                         qualified names of binary classes to process\n\
\ \n\
\ Null annotation options:\n\
\    -nullAnnotations:<suboptions>\n\
\                      enable use of annotations for specifying null contracts;\n\
\                      <suboptions> is a non-empty, comma-separated list of:\n\
\        nullable=<typename>\n\
\                      specifies the fully qualified name of an annotation type\n\
\                      to be used for marking types whose values include null\n\
\        nonnull=<typename>\n\
\                      specifies the fully qualified name of an annotation type\n\
\                      to be used for marking types whose values cannot be null\n\
\        emulate       tells the compiler to emulate the above annotation types\n\
\                      although they do not exist on the classpath\n\
\        import        tells the compiler to import the above annotation types\n\
\                      without specific mention in the sources such that their\n\
\                      simple names can be used without explicit imports\n\
\ \n\
\ Advanced options:\n\
\    @<file>            read command line arguments from file\n\
\    -maxProblems <n>   max number of problems per compilation unit (100 by\n\

Lines 116-122 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (-1 / +32 lines)
116	* Benjamin Muskalla - added the following constants	116	* Benjamin Muskalla - added the following constants
117	* MissingSynchronizedModifierInInheritedMethod	117	* MissingSynchronizedModifierInInheritedMethod
118	* Stephan Herrmann - added the following constants	118	* Stephan Herrmann - added the following constants
119	* UnusedObjectAllocation	119	* UnusedObjectAllocation
		120	* DefiniteNullFromNonNullMethod
		121	* PotentialNullFromNonNullMethod
		122	* NonNullReturnInsufficientInfo
		123	* DefiniteNullToNonnullParameter
		124	* PotentialNullToNonnullParameter
		125	* NonNullParameterInsufficientInfo
		126	* ConflictingTypeEmulation
		127	* IllegalRedefinitionToNullableReturn
		128	* IllegalRedefinitionToNonNullParameter
120	*******************************************************************************/	129	*******************************************************************************/
121	package org.eclipse.jdt.core.compiler;	130	package org.eclipse.jdt.core.compiler;
122		131
Lines 1340-1345 Link Here
1340	int JavadocTypeArgumentsForRawGenericConstructor = Javadoc + Internal + 859;	1349	int JavadocTypeArgumentsForRawGenericConstructor = Javadoc + Internal + 859;
1341		1350
1342	/**	1351	/**
		1352	* Null Annotations
		1353	*/
		1354	/** @since 3.7 */
		1355	int DefiniteNullFromNonNullMethod = MethodRelated + 880;
		1356	/** @since 3.7 */
		1357	int PotentialNullFromNonNullMethod = MethodRelated + 881;
		1358	/** @since 3.7 */
		1359	int NonNullReturnInsufficientInfo = MethodRelated + 882;
		1360	/** @since 3.7 */
		1361	int DefiniteNullToNonnullParameter = MethodRelated + 883;
		1362	/** @since 3.7 */
		1363	int PotentialNullToNonnullParameter = MethodRelated + 884;
		1364	/** @since 3.7 */
		1365	int NonNullParameterInsufficientInfo = MethodRelated + 885;
		1366	/** @since 3.7 */
		1367	int ConflictingTypeEmulation = ImportRelated + 886;
		1368	/** @since 3.7 */
		1369	int IllegalRedefinitionToNullableReturn = MethodRelated + 887;
		1370	/** @since 3.7 */
		1371	int IllegalRedefinitionToNonNullParameter = MethodRelated + 888;
		1372
		1373	/**
1343	* External problems -- These are problems defined by other plugins	1374	* External problems -- These are problems defined by other plugins
1344	*/	1375	*/
1345		1376

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AbstractMethodDeclaration.java (-1 / +7 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	12	package org.eclipse.jdt.internal.compiler.ast;
12		13
Lines 100-105 Link Here
100	} else if (paramAnnotations != null) {	101	} else if (paramAnnotations != null) {
101	paramAnnotations[i] = Binding.NO_ANNOTATIONS;	102	paramAnnotations[i] = Binding.NO_ANNOTATIONS;
102	}	103	}
		104	// transfer nullness info from the argument to the method:
		105	if ((argument.binding.tagBits & (TagBits.AnnotationNonNull\|TagBits.AnnotationNullable)) != 0) {
		106	if (this.binding.parameterNonNullness == null)
		107	this.binding.parameterNonNullness = new Boolean[this.arguments.length];
		108	this.binding.parameterNonNullness[i] = Boolean.valueOf((argument.binding.tagBits & TagBits.AnnotationNonNull) != 0);
		109	}
103	}	110	}
104	if (paramAnnotations != null)	111	if (paramAnnotations != null)
105	this.binding.setParameterAnnotations(paramAnnotations);	112	this.binding.setParameterAnnotations(paramAnnotations);
Lines 415-421 Link Here
415	}	422	}
416		423
417	try {	424	try {
418	bindArguments();
419	bindThrownExceptions();	425	bindThrownExceptions();
420	resolveJavadoc();	426	resolveJavadoc();
421	resolveAnnotations(this.scope, this.annotations, this.binding);	427	resolveAnnotations(this.scope, this.annotations, this.binding);

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Annotation.java (+7 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	12	package org.eclipse.jdt.internal.compiler.ast;
12		13
Lines 161-166 Link Here
161	case TypeIds.T_JavaLangSuppressWarnings :	162	case TypeIds.T_JavaLangSuppressWarnings :
162	tagBits \|= TagBits.AnnotationSuppressWarnings;	163	tagBits \|= TagBits.AnnotationSuppressWarnings;
163	break;	164	break;
		165	case TypeIds.T_ConfiguredAnnotationNullable :
		166	tagBits \|= TagBits.AnnotationNullable;
		167	break;
		168	case TypeIds.T_ConfiguredAnnotationNonNull :
		169	tagBits \|= TagBits.AnnotationNonNull;
		170	break;
164	}	171	}
165	return tagBits;	172	return tagBits;
166	}	173	}

Lines 8-14 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-1 / +20 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Nick Teryaev - fix for bug (https://bugs.eclipse.org/bugs/show_bug.cgi?id=40752)	10	* Nick Teryaev - fix for bug (https://bugs.eclipse.org/bugs/show_bug.cgi?id=40752)
11	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	11	* Stephan Herrmann - Contributions for
		12	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		13	* bug 186342 - [compiler][null]Using annotations for null checking
12	*******************************************************************************/	14	*******************************************************************************/
13	package org.eclipse.jdt.internal.compiler.ast;	15	package org.eclipse.jdt.internal.compiler.ast;
14		16
Lines 80-85 Link Here
80	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);	82	this.arguments[i].checkNPE(currentScope, flowContext, flowInfo);
81	}	83	}
82	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();	84	flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo).unconditionalInits();
		85	// compare actual null-status against parameter annotations of the called method:
		86	int nullStatus = this.arguments[i].nullStatus(flowInfo);
		87	if (nullStatus != FlowInfo.NON_NULL
		88	&& this.binding.parameterNonNullness != null
		89	&& this.binding.parameterNonNullness[i].booleanValue()) // if @NonNull is required
		90	{
		91	char[][] annotationName = currentScope.environment().globalOptions.nonNullAnnotationName;
		92	currentScope.problemReporter().possiblyNullToNonNullParameter(this.arguments[i], nullStatus, annotationName[annotationName.length-1]);
		93	}
83	}	94	}
84	}	95	}
85	ReferenceBinding[] thrownExceptions;	96	ReferenceBinding[] thrownExceptions;
Lines 250-255 Link Here
250	}	261	}
251	}	262	}
252	public int nullStatus(FlowInfo flowInfo) {	263	public int nullStatus(FlowInfo flowInfo) {
		264	if (this.binding.isValidBinding()) {
		265	// try to retrieve null status of this message send from an annotation of the called method:
		266	long tagBits = this.binding.tagBits;
		267	if ((tagBits & TagBits.AnnotationNonNull) != 0)
		268	return FlowInfo.NON_NULL;
		269	if ((tagBits & TagBits.AnnotationNullable) != 0)
		270	return FlowInfo.POTENTIALLY_NULL;
		271	}
253	return FlowInfo.UNKNOWN;	272	return FlowInfo.UNKNOWN;
254	}	273	}
255		274

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java (+7 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.ast;	12	package org.eclipse.jdt.internal.compiler.ast;
12		13
Lines 89-94 Link Here
89	if (this.binding != null && this.binding.declaringClass == declaringElement)	90	if (this.binding != null && this.binding.declaringClass == declaringElement)
90	this.bits &= ~ASTNode.CanBeStatic;	91	this.bits &= ~ASTNode.CanBeStatic;
91	}	92	}
		93	// leverage null-info from parameter annotations:
		94	long argumentTagBits = this.arguments[i].binding.tagBits;
		95	if ((argumentTagBits & TagBits.AnnotationNullable) != 0)
		96	flowInfo.markPotentiallyNullBit(this.arguments[i].binding);
		97	else if ((argumentTagBits & TagBits.AnnotationNonNull) != 0)
		98	flowInfo.markAsDefinitelyNonNull(this.arguments[i].binding);
92	}	99	}
93	}	100	}
94	if (this.binding.declaringClass instanceof MemberTypeBinding && !this.binding.declaringClass.isStatic()) {	101	if (this.binding.declaringClass instanceof MemberTypeBinding && !this.binding.declaringClass.isStatic()) {

Lines 7-13 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (-1 / +15 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Stephan Herrmann - Contribution for bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE	10	* Stephan Herrmann - Contributions for
		11	* bug 319201 - [null] no warning when unboxing SingleNameReference causes NPE
		12	* bug 186342 - [compiler][null]Using annotations for null checking
11	*******************************************************************************/	13	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.ast;	14	package org.eclipse.jdt.internal.compiler.ast;
13		15
Lines 40-45 Link Here
40	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {	42	if ((this.expression.implicitConversion & TypeIds.UNBOXING) != 0) {
41	this.expression.checkNPE(currentScope, flowContext, flowInfo);	43	this.expression.checkNPE(currentScope, flowContext, flowInfo);
42	}	44	}
		45	if (this.expression.nullStatus(flowInfo) != FlowInfo.NON_NULL) {
		46	// if we can't prove non-null check against declared null-ness of the enclosing method:
		47	AbstractMethodDeclaration referenceMethod = currentScope.methodScope().referenceMethod();
		48	if (referenceMethod != null) {
		49	MethodBinding method = referenceMethod.binding;
		50	if ((method.tagBits & TagBits.AnnotationNonNull) != 0) {
		51	char[][] annotationName = currentScope.environment().globalOptions.nonNullAnnotationName;
		52	currentScope.problemReporter().possiblyNullFromNonNullMethod(this, this.expression.nullStatus(flowInfo),
		53	annotationName[annotationName.length-1]);
		54	}
		55	}
		56	}
43	}	57	}
44	this.initStateIndex =	58	this.initStateIndex =
45	currentScope.methodScope().recordInitializationStates(flowInfo);	59	currentScope.methodScope().recordInitializationStates(flowInfo);

Lines 10-15 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java (+81 lines)
10	* Benjamin Muskalla - Contribution for bug 239066	10	* Benjamin Muskalla - Contribution for bug 239066
11	* Stephan Herrmann - Contribution for bug 236385	11	* Stephan Herrmann - Contribution for bug 236385
12	* Stephan Herrmann - Contribution for bug 295551	12	* Stephan Herrmann - Contribution for bug 295551
		13	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
13	*******************************************************************************/	14	*******************************************************************************/
14	package org.eclipse.jdt.internal.compiler.impl;	15	package org.eclipse.jdt.internal.compiler.impl;
15		16
Lines 106-111 Link Here
106	public static final String OPTION_ReportNullReference = "org.eclipse.jdt.core.compiler.problem.nullReference"; //$NON-NLS-1$	107	public static final String OPTION_ReportNullReference = "org.eclipse.jdt.core.compiler.problem.nullReference"; //$NON-NLS-1$
107	public static final String OPTION_ReportPotentialNullReference = "org.eclipse.jdt.core.compiler.problem.potentialNullReference"; //$NON-NLS-1$	108	public static final String OPTION_ReportPotentialNullReference = "org.eclipse.jdt.core.compiler.problem.potentialNullReference"; //$NON-NLS-1$
108	public static final String OPTION_ReportRedundantNullCheck = "org.eclipse.jdt.core.compiler.problem.redundantNullCheck"; //$NON-NLS-1$	109	public static final String OPTION_ReportRedundantNullCheck = "org.eclipse.jdt.core.compiler.problem.redundantNullCheck"; //$NON-NLS-1$
		110	public static final String OPTION_ReportNullContractViolation = "org.eclipse.jdt.core.compiler.problem.nullContractViolation"; //$NON-NLS-1$
		111	public static final String OPTION_ReportPotentialNullContractViolation = "org.eclipse.jdt.core.compiler.problem.potentialNullContractViolation"; //$NON-NLS-1$
		112	public static final String OPTION_ReportNullContractInsufficientInfo = "org.eclipse.jdt.core.compiler.problem.nullContractInsufficientInfo"; //$NON-NLS-1$
109	public static final String OPTION_ReportAutoboxing = "org.eclipse.jdt.core.compiler.problem.autoboxing"; //$NON-NLS-1$	113	public static final String OPTION_ReportAutoboxing = "org.eclipse.jdt.core.compiler.problem.autoboxing"; //$NON-NLS-1$
110	public static final String OPTION_ReportAnnotationSuperInterface = "org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"; //$NON-NLS-1$	114	public static final String OPTION_ReportAnnotationSuperInterface = "org.eclipse.jdt.core.compiler.problem.annotationSuperInterface"; //$NON-NLS-1$
111	public static final String OPTION_ReportMissingOverrideAnnotation = "org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"; //$NON-NLS-1$	115	public static final String OPTION_ReportMissingOverrideAnnotation = "org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation"; //$NON-NLS-1$
Lines 141-146 Link Here
141	public static final String OPTION_ReportMissingAnnotation = "org.eclipse.jdt.core.compiler.problem.missingAnnotation"; //$NON-NLS-1$	145	public static final String OPTION_ReportMissingAnnotation = "org.eclipse.jdt.core.compiler.problem.missingAnnotation"; //$NON-NLS-1$
142	public static final String OPTION_ReportMissingJavadoc = "org.eclipse.jdt.core.compiler.problem.missingJavadoc"; //$NON-NLS-1$	146	public static final String OPTION_ReportMissingJavadoc = "org.eclipse.jdt.core.compiler.problem.missingJavadoc"; //$NON-NLS-1$
143		147
		148	public static final String OPTION_NullableAnnotationName = "org.eclipse.jdt.core.compiler.annotation.nullable"; //$NON-NLS-1$
		149	public static final String OPTION_NonNullAnnotationName = "org.eclipse.jdt.core.compiler.annotation.nonnull"; //$NON-NLS-1$
		150	public static final String OPTION_EmulateNullAnnotationTypes = "org.eclipse.jdt.core.compiler.annotation.emulate"; //$NON-NLS-1$
		151	public static final String OPTION_DefaultImportNullAnnotationTypes = "org.eclipse.jdt.core.compiler.annotation.defaultImport"; //$NON-NLS-1$
		152
144	/**	153	/**
145	* Possible values for configurable options	154	* Possible values for configurable options
146	*/	155	*/
Lines 170-175 Link Here
170	public static final String NO_TAG = "no_tag"; //$NON-NLS-1$	179	public static final String NO_TAG = "no_tag"; //$NON-NLS-1$
171	public static final String ALL_STANDARD_TAGS = "all_standard_tags"; //$NON-NLS-1$	180	public static final String ALL_STANDARD_TAGS = "all_standard_tags"; //$NON-NLS-1$
172		181
		182	private static final char[][] DEFAULT_NONNULL_ANNOTATION_NAME = CharOperation.splitOn('.', "org.eclipse.jdt.annotation.NonNull".toCharArray()); //$NON-NLS-1$
		183	private static final char[][] DEFAULT_NULLABLE_ANNOTATION_NAME = CharOperation.splitOn('.', "org.eclipse.jdt.annotation.Nullable".toCharArray()); //$NON-NLS-1$
		184
173	/**	185	/**
174	* Bit mask for configurable problems (error/warning threshold)	186	* Bit mask for configurable problems (error/warning threshold)
175	* Note: bitmask assumes 3 highest bits to denote irritant group (to allow storing 8 groups of 29 bits each	187	* Note: bitmask assumes 3 highest bits to denote irritant group (to allow storing 8 groups of 29 bits each
Lines 243-248 Link Here
243	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 \| ASTNode.Bit4;	255	public static final int UnusedObjectAllocation = IrritantSet.GROUP2 \| ASTNode.Bit4;
244	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;	256	public static final int MethodCanBeStatic = IrritantSet.GROUP2 \| ASTNode.Bit5;
245	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;	257	public static final int MethodCanBePotentiallyStatic = IrritantSet.GROUP2 \| ASTNode.Bit6;
		258	public static final int NullContractViolation = IrritantSet.GROUP2 \| ASTNode.Bit7;
		259	public static final int PotentialNullContractViolation = IrritantSet.GROUP2 \| ASTNode.Bit8;
		260	public static final int NullContractInsufficientInfo = IrritantSet.GROUP2 \| ASTNode.Bit9;
246		261
247	// Severity level for handlers	262	// Severity level for handlers
248	/**	263	/**
Lines 364-369 Link Here
364	public boolean includeNullInfoFromAsserts;	379	public boolean includeNullInfoFromAsserts;
365	/** Controls whether forced generic type problems get reported */	380	/** Controls whether forced generic type problems get reported */
366	public boolean reportUnavoidableGenericTypeProblems;	381	public boolean reportUnavoidableGenericTypeProblems;
		382	/** Fully qualified name of annotation to use as marker for nullable types. */
		383	public char[][] nullableAnnotationName;
		384	/** Fully qualified name of annotation to use as marker for nonnull types. */
		385	public char[][] nonNullAnnotationName;
		386	/** Should null annotation types be emulated by synthetic bindings? */
		387	public boolean emulateNullAnnotationTypes;
		388	/** Should null annotation types be imported by default? */
		389	public boolean defaultImportNullAnnotationTypes;
367		390
368	// keep in sync with warningTokenToIrritant and warningTokenFromIrritant	391	// keep in sync with warningTokenToIrritant and warningTokenFromIrritant
369	public final static String[] warningTokens = {	392	public final static String[] warningTokens = {
Lines 503-508 Link Here
503	return OPTION_ReportPotentialNullReference;	526	return OPTION_ReportPotentialNullReference;
504	case RedundantNullCheck :	527	case RedundantNullCheck :
505	return OPTION_ReportRedundantNullCheck;	528	return OPTION_ReportRedundantNullCheck;
		529	case NullContractViolation :
		530	return OPTION_ReportNullContractViolation;
		531	case PotentialNullContractViolation :
		532	return OPTION_ReportPotentialNullContractViolation;
		533	case NullContractInsufficientInfo :
		534	return OPTION_ReportNullContractInsufficientInfo;
506	case AutoBoxing :	535	case AutoBoxing :
507	return OPTION_ReportAutoboxing;	536	return OPTION_ReportAutoboxing;
508	case AnnotationSuperInterface :	537	case AnnotationSuperInterface :
Lines 748-753 Link Here
748	case NullReference :	777	case NullReference :
749	case PotentialNullReference :	778	case PotentialNullReference :
750	case RedundantNullCheck :	779	case RedundantNullCheck :
		780	case NullContractViolation :
		781	case PotentialNullContractViolation :
		782	case NullContractInsufficientInfo :
751	return "null"; //$NON-NLS-1$	783	return "null"; //$NON-NLS-1$
752	case FallthroughCase :	784	case FallthroughCase :
753	return "fallthrough"; //$NON-NLS-1$	785	return "fallthrough"; //$NON-NLS-1$
Lines 923-928 Link Here
923	optionsMap.put(OPTION_ReportNullReference, getSeverityString(NullReference));	955	optionsMap.put(OPTION_ReportNullReference, getSeverityString(NullReference));
924	optionsMap.put(OPTION_ReportPotentialNullReference, getSeverityString(PotentialNullReference));	956	optionsMap.put(OPTION_ReportPotentialNullReference, getSeverityString(PotentialNullReference));
925	optionsMap.put(OPTION_ReportRedundantNullCheck, getSeverityString(RedundantNullCheck));	957	optionsMap.put(OPTION_ReportRedundantNullCheck, getSeverityString(RedundantNullCheck));
		958	optionsMap.put(OPTION_ReportNullContractViolation, getSeverityString(NullContractViolation));
		959	optionsMap.put(OPTION_ReportPotentialNullContractViolation, getSeverityString(PotentialNullContractViolation));
		960	optionsMap.put(OPTION_ReportNullContractInsufficientInfo, getSeverityString(NullContractInsufficientInfo));
926	optionsMap.put(OPTION_SuppressWarnings, this.suppressWarnings ? ENABLED : DISABLED);	961	optionsMap.put(OPTION_SuppressWarnings, this.suppressWarnings ? ENABLED : DISABLED);
927	optionsMap.put(OPTION_SuppressOptionalErrors, this.suppressOptionalErrors ? ENABLED : DISABLED);	962	optionsMap.put(OPTION_SuppressOptionalErrors, this.suppressOptionalErrors ? ENABLED : DISABLED);
928	optionsMap.put(OPTION_ReportUnhandledWarningToken, getSeverityString(UnhandledWarningToken));	963	optionsMap.put(OPTION_ReportUnhandledWarningToken, getSeverityString(UnhandledWarningToken));
Lines 943-948 Link Here
943	optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);	978	optionsMap.put(OPTION_IncludeNullInfoFromAsserts, this.includeNullInfoFromAsserts ? ENABLED : DISABLED);
944	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));	979	optionsMap.put(OPTION_ReportMethodCanBeStatic, getSeverityString(MethodCanBeStatic));
945	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));	980	optionsMap.put(OPTION_ReportMethodCanBePotentiallyStatic, getSeverityString(MethodCanBePotentiallyStatic));
		981	if (this.nullableAnnotationName != null) {
		982	char[] compoundName = CharOperation.concatWith(this.nullableAnnotationName, '.');
		983	optionsMap.put(OPTION_NullableAnnotationName, String.valueOf(compoundName));
		984	}
		985	if (this.nonNullAnnotationName != null) {
		986	char[] compoundName = CharOperation.concatWith(this.nonNullAnnotationName, '.');
		987	optionsMap.put(OPTION_NonNullAnnotationName, String.valueOf(compoundName));
		988	}
		989	optionsMap.put(OPTION_EmulateNullAnnotationTypes, this.emulateNullAnnotationTypes ? ENABLED : DISABLED);
		990	optionsMap.put(OPTION_DefaultImportNullAnnotationTypes, this.defaultImportNullAnnotationTypes ? ENABLED : DISABLED);
946	return optionsMap;	991	return optionsMap;
947	}	992	}
948		993
Lines 1351-1356 Link Here
1351	if ((optionValue = optionsMap.get(OPTION_ReportNullReference)) != null) updateSeverity(NullReference, optionValue);	1396	if ((optionValue = optionsMap.get(OPTION_ReportNullReference)) != null) updateSeverity(NullReference, optionValue);
1352	if ((optionValue = optionsMap.get(OPTION_ReportPotentialNullReference)) != null) updateSeverity(PotentialNullReference, optionValue);	1397	if ((optionValue = optionsMap.get(OPTION_ReportPotentialNullReference)) != null) updateSeverity(PotentialNullReference, optionValue);
1353	if ((optionValue = optionsMap.get(OPTION_ReportRedundantNullCheck)) != null) updateSeverity(RedundantNullCheck, optionValue);	1398	if ((optionValue = optionsMap.get(OPTION_ReportRedundantNullCheck)) != null) updateSeverity(RedundantNullCheck, optionValue);
		1399	if ((optionValue = optionsMap.get(OPTION_ReportNullContractViolation)) != null) updateSeverity(NullContractViolation, optionValue);
		1400	if ((optionValue = optionsMap.get(OPTION_ReportPotentialNullContractViolation)) != null) updateSeverity(PotentialNullContractViolation, optionValue);
		1401	if ((optionValue = optionsMap.get(OPTION_ReportNullContractInsufficientInfo)) != null) updateSeverity(NullContractInsufficientInfo, optionValue);
1354	if ((optionValue = optionsMap.get(OPTION_ReportAutoboxing)) != null) updateSeverity(AutoBoxing, optionValue);	1402	if ((optionValue = optionsMap.get(OPTION_ReportAutoboxing)) != null) updateSeverity(AutoBoxing, optionValue);
1355	if ((optionValue = optionsMap.get(OPTION_ReportAnnotationSuperInterface)) != null) updateSeverity(AnnotationSuperInterface, optionValue);	1403	if ((optionValue = optionsMap.get(OPTION_ReportAnnotationSuperInterface)) != null) updateSeverity(AnnotationSuperInterface, optionValue);
1356	if ((optionValue = optionsMap.get(OPTION_ReportMissingOverrideAnnotation)) != null) updateSeverity(MissingOverrideAnnotation, optionValue);	1404	if ((optionValue = optionsMap.get(OPTION_ReportMissingOverrideAnnotation)) != null) updateSeverity(MissingOverrideAnnotation, optionValue);
Lines 1485-1490 Link Here
1485	this.storeAnnotations = false;	1533	this.storeAnnotations = false;
1486	}	1534	}
1487	}	1535	}
		1536	if ((optionValue = optionsMap.get(OPTION_NullableAnnotationName)) != null) {
		1537	this.nullableAnnotationName = CharOperation.splitAndTrimOn('.', ((String)optionValue).toCharArray());
		1538	}
		1539	if ((optionValue = optionsMap.get(OPTION_NonNullAnnotationName)) != null) {
		1540	this.nonNullAnnotationName = CharOperation.splitAndTrimOn('.', ((String)optionValue).toCharArray());
		1541	}
		1542	if ((optionValue = optionsMap.get(OPTION_EmulateNullAnnotationTypes)) != null) {
		1543	if (ENABLED.equals(optionValue)) {
		1544	this.emulateNullAnnotationTypes = true;
		1545	// ensure that we actually have annotation names to emulate:
		1546	if (this.nullableAnnotationName == null)
		1547	this.nullableAnnotationName = DEFAULT_NULLABLE_ANNOTATION_NAME;
		1548	if (this.nonNullAnnotationName == null)
		1549	this.nonNullAnnotationName = DEFAULT_NONNULL_ANNOTATION_NAME;
		1550	} else if (DISABLED.equals(optionValue)) {
		1551	this.emulateNullAnnotationTypes = false;
		1552	}
		1553	}
		1554	if ((optionValue = optionsMap.get(OPTION_DefaultImportNullAnnotationTypes)) != null) {
		1555	if (ENABLED.equals(optionValue)) {
		1556	this.defaultImportNullAnnotationTypes = true;
		1557	// ensure that we actually have annotation names to be used for default imports:
		1558	if (this.nullableAnnotationName == null)
		1559	this.nullableAnnotationName = DEFAULT_NULLABLE_ANNOTATION_NAME;
		1560	if (this.nonNullAnnotationName == null)
		1561	this.nonNullAnnotationName = DEFAULT_NONNULL_ANNOTATION_NAME;
		1562	} else if (DISABLED.equals(optionValue)) {
		1563	this.defaultImportNullAnnotationTypes = false;
		1564	}
		1565	}
1488	}	1566	}
1489	public String toString() {	1567	public String toString() {
1490	StringBuffer buf = new StringBuffer("CompilerOptions:"); //$NON-NLS-1$	1568	StringBuffer buf = new StringBuffer("CompilerOptions:"); //$NON-NLS-1$
Lines 1560-1565 Link Here
1560	buf.append("\n\t- null reference: ").append(getSeverityString(NullReference)); //$NON-NLS-1$	1638	buf.append("\n\t- null reference: ").append(getSeverityString(NullReference)); //$NON-NLS-1$
1561	buf.append("\n\t- potential null reference: ").append(getSeverityString(PotentialNullReference)); //$NON-NLS-1$	1639	buf.append("\n\t- potential null reference: ").append(getSeverityString(PotentialNullReference)); //$NON-NLS-1$
1562	buf.append("\n\t- redundant null check: ").append(getSeverityString(RedundantNullCheck)); //$NON-NLS-1$	1640	buf.append("\n\t- redundant null check: ").append(getSeverityString(RedundantNullCheck)); //$NON-NLS-1$
		1641	buf.append("\n\t- null contract violation: ").append(getSeverityString(NullContractViolation)); //$NON-NLS-1$
		1642	buf.append("\n\t- potential null contract vialotation: ").append(getSeverityString(PotentialNullContractViolation)); //$NON-NLS-1$
		1643	buf.append("\n\t- insufficient information for checking null contract: ").append(getSeverityString(NullContractInsufficientInfo)); //$NON-NLS-1$
1563	buf.append("\n\t- autoboxing: ").append(getSeverityString(AutoBoxing)); //$NON-NLS-1$	1644	buf.append("\n\t- autoboxing: ").append(getSeverityString(AutoBoxing)); //$NON-NLS-1$
1564	buf.append("\n\t- annotation super interface: ").append(getSeverityString(AnnotationSuperInterface)); //$NON-NLS-1$	1645	buf.append("\n\t- annotation super interface: ").append(getSeverityString(AnnotationSuperInterface)); //$NON-NLS-1$
1565	buf.append("\n\t- missing @Override annotation: ").append(getSeverityString(MissingOverrideAnnotation)); //$NON-NLS-1$	1646	buf.append("\n\t- missing @Override annotation: ").append(getSeverityString(MissingOverrideAnnotation)); //$NON-NLS-1$

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/IrritantSet.java (-3 / +11 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11		12
12	package org.eclipse.jdt.internal.compiler.impl;	13	package org.eclipse.jdt.internal.compiler.impl;
Lines 58-66 Link Here
58	public static final IrritantSet UNCHECKED = new IrritantSet(CompilerOptions.UncheckedTypeOperation);	59	public static final IrritantSet UNCHECKED = new IrritantSet(CompilerOptions.UncheckedTypeOperation);
59	public static final IrritantSet UNQUALIFIED_FIELD_ACCESS = new IrritantSet(CompilerOptions.UnqualifiedFieldAccess);	60	public static final IrritantSet UNQUALIFIED_FIELD_ACCESS = new IrritantSet(CompilerOptions.UnqualifiedFieldAccess);
60		61
61	public static final IrritantSet COMPILER_DEFAULT_ERRORS = new IrritantSet(0); // no optional error by default	62	public static final IrritantSet COMPILER_DEFAULT_ERRORS = new IrritantSet(0); // see static initializer below
62	public static final IrritantSet COMPILER_DEFAULT_WARNINGS = new IrritantSet(0); // see static initializer below	63	public static final IrritantSet COMPILER_DEFAULT_WARNINGS = new IrritantSet(0); // see static initializer below
63	static {	64	static {
		65	COMPILER_DEFAULT_ERRORS
		66	.set(CompilerOptions.NullContractViolation);
64	COMPILER_DEFAULT_WARNINGS	67	COMPILER_DEFAULT_WARNINGS
65	// group-0 warnings enabled by default	68	// group-0 warnings enabled by default
66	.set(	69	.set(
Lines 98-104 Link Here
98	// group-2 warnings enabled by default	101	// group-2 warnings enabled by default
99	.set(	102	.set(
100	CompilerOptions.DeadCode	103	CompilerOptions.DeadCode
101	\|CompilerOptions.Tasks);	104	\| CompilerOptions.Tasks
		105	\| CompilerOptions.PotentialNullContractViolation
		106	\| CompilerOptions.NullContractInsufficientInfo);
102		107
103	ALL.setAll();	108	ALL.setAll();
104	HIDING	109	HIDING
Lines 107-113 Link Here
107	.set(CompilerOptions.TypeHiding);	112	.set(CompilerOptions.TypeHiding);
108	NULL	113	NULL
109	.set(CompilerOptions.PotentialNullReference)	114	.set(CompilerOptions.PotentialNullReference)
110	.set(CompilerOptions.RedundantNullCheck);	115	.set(CompilerOptions.RedundantNullCheck)
		116	.set(CompilerOptions.NullContractViolation)
		117	.set(CompilerOptions.PotentialNullContractViolation)
		118	.set(CompilerOptions.NullContractInsufficientInfo);
111	RESTRICTION.set(CompilerOptions.DiscouragedReference);	119	RESTRICTION.set(CompilerOptions.DiscouragedReference);
112	STATIC_ACCESS.set(CompilerOptions.NonStaticAccessToStatic);	120	STATIC_ACCESS.set(CompilerOptions.NonStaticAccessToStatic);
113	UNUSED	121	UNUSED

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/BinaryTypeBinding.java (+50 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 553-558 Link Here
553	isAnnotationType() ? convertMemberValue(method.getDefaultValue(), this.environment, missingTypeNames) : null,	554	isAnnotationType() ? convertMemberValue(method.getDefaultValue(), this.environment, missingTypeNames) : null,
554	this.environment);	555	this.environment);
555		556
		557	scanForNullAnnotation(method, result);
		558
556	if (use15specifics)	559	if (use15specifics)
557	result.tagBits \|= method.getTagBits();	560	result.tagBits \|= method.getTagBits();
558	result.typeVariables = typeVars;	561	result.typeVariables = typeVars;
Lines 1086-1091 Link Here
1086	AnnotationBinding[] retrieveAnnotations(Binding binding) {	1089	AnnotationBinding[] retrieveAnnotations(Binding binding) {
1087	return AnnotationBinding.addStandardAnnotations(super.retrieveAnnotations(binding), binding.getAnnotationTagBits(), this.environment);	1090	return AnnotationBinding.addStandardAnnotations(super.retrieveAnnotations(binding), binding.getAnnotationTagBits(), this.environment);
1088	}	1091	}
		1092	private void scanForNullAnnotation(IBinaryMethod method, MethodBinding result) {
		1093	char[][] nullableAnnotationName = this.environment.globalOptions.nullableAnnotationName;
		1094	char[][] nonNullAnnotationName = this.environment.globalOptions.nonNullAnnotationName;
		1095	if (nullableAnnotationName == null \|\| nonNullAnnotationName == null)
		1096	return; // not configured to use null annotations
		1097
		1098	IBinaryAnnotation[] annotations = method.getAnnotations();
		1099	if (annotations != null) {
		1100	for (int i = 0; i < annotations.length; i++) {
		1101	char[] annotationTypeName = annotations[i].getTypeName();
		1102	if (annotationTypeName[0] != 'L')
		1103	continue;
		1104	char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
		1105	if (CharOperation.equals(typeName, nonNullAnnotationName)) {
		1106	result.tagBits \|= TagBits.AnnotationNonNull;
		1107	return;
		1108	}
		1109	if (CharOperation.equals(typeName, nullableAnnotationName)) {
		1110	result.tagBits \|= TagBits.AnnotationNullable;
		1111	return;
		1112	}
		1113	}
		1114	}
		1115
		1116	for (int j = 0; j < result.parameters.length; j++) {
		1117	IBinaryAnnotation[] paramAnnotations = method.getParameterAnnotations(j);
		1118	if (paramAnnotations != null) {
		1119	for (int i = 0; i < paramAnnotations.length; i++) {
		1120	char[] annotationTypeName = paramAnnotations[i].getTypeName();
		1121	if (annotationTypeName[0] != 'L')
		1122	continue;
		1123	char[][] typeName = CharOperation.splitOn('/', annotationTypeName, 1, annotationTypeName.length-1); // cut of leading 'L' and trailing ';'
		1124	if (CharOperation.equals(typeName, nonNullAnnotationName)) {
		1125	if (result.parameterNonNullness == null)
		1126	result.parameterNonNullness = new Boolean[result.parameters.length];
		1127	result.parameterNonNullness[i] = Boolean.TRUE;
		1128	break;
		1129	} else if (CharOperation.equals(typeName, nullableAnnotationName)) {
		1130	if (result.parameterNonNullness == null)
		1131	result.parameterNonNullness = new Boolean[result.parameters.length];
		1132	result.parameterNonNullness[i] = Boolean.FALSE;
		1133	break;
		1134	}
		1135	}
		1136	}
		1137	}
		1138	}
1089	SimpleLookupTable storedAnnotations(boolean forceInitialize) {	1139	SimpleLookupTable storedAnnotations(boolean forceInitialize) {
1090	if (forceInitialize && this.storedAnnotations == null) {	1140	if (forceInitialize && this.storedAnnotations == null) {
1091	if (!this.environment.globalOptions.storeAnnotations)	1141	if (!this.environment.globalOptions.storeAnnotations)

Lines 7-13 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java (-7 / +42 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Erling Ellingsen - patch for bug 125570	10	* Erling Ellingsen - patch for bug 125570
		11	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.lookup;	13	package org.eclipse.jdt.internal.compiler.lookup;
13		14
Lines 160-166 Link Here
160		161
161	// allocate the import array, add java.lang.* by default	162	// allocate the import array, add java.lang.* by default
162	int numberOfStatements = this.referenceContext.imports.length;	163	int numberOfStatements = this.referenceContext.imports.length;
163	int numberOfImports = numberOfStatements + 1;	164	int numberOfDefaultImports = 1;
		165	if (this.environment.globalOptions.defaultImportNullAnnotationTypes)
		166	numberOfDefaultImports += 2;
		167	int numberOfImports = numberOfStatements + numberOfDefaultImports;
164	for (int i = 0; i < numberOfStatements; i++) {	168	for (int i = 0; i < numberOfStatements; i++) {
165	ImportReference importReference = this.referenceContext.imports[i];	169	ImportReference importReference = this.referenceContext.imports[i];
166	if (((importReference.bits & ASTNode.OnDemand) != 0) && CharOperation.equals(TypeConstants.JAVA_LANG, importReference.tokens) && !importReference.isStatic()) {	170	if (((importReference.bits & ASTNode.OnDemand) != 0) && CharOperation.equals(TypeConstants.JAVA_LANG, importReference.tokens) && !importReference.isStatic()) {
Lines 169-176 Link Here
169	}	173	}
170	}	174	}
171	ImportBinding[] resolvedImports = new ImportBinding[numberOfImports];	175	ImportBinding[] resolvedImports = new ImportBinding[numberOfImports];
172	resolvedImports[0] = getDefaultImports()[0];	176	ImportBinding[] defaultImports = getDefaultImports(); // consistent number of default imports is ensured in LookupEnvironment.makeNullAnnotationTypeImports()
173	int index = 1;	177	for (int i = 0; i < numberOfDefaultImports; i++) {
		178	resolvedImports[i] = defaultImports[i];
		179	}
		180	int index = numberOfDefaultImports;
174		181
175	nextImport : for (int i = 0; i < numberOfStatements; i++) {	182	nextImport : for (int i = 0; i < numberOfStatements; i++) {
176	ImportReference importReference = this.referenceContext.imports[i];	183	ImportReference importReference = this.referenceContext.imports[i];
Lines 303-308 Link Here
303	return; // can be called when a field constant is resolved before static imports	310	return; // can be called when a field constant is resolved before static imports
304	if (this.referenceContext.imports == null) {	311	if (this.referenceContext.imports == null) {
305	this.typeOrPackageCache = new HashtableOfObject(1);	312	this.typeOrPackageCache = new HashtableOfObject(1);
		313	for (int i = 0; i < this.imports.length; i++) {
		314	// cache default-imported null annotation types:
		315	if (!this.imports[i].onDemand) {
		316	char[][] importName = this.imports[i].compoundName;
		317	this.typeOrPackageCache.put(importName[importName.length-1], this.imports[i].resolvedImport);
		318	}
		319	}
306	return;	320	return;
307	}	321	}
308		322
Lines 327-335 Link Here
327	break;	341	break;
328	}	342	}
329	}	343	}
		344	int numberOfDefaultImports = 1;
		345	if (this.environment.globalOptions.defaultImportNullAnnotationTypes) {
		346	numberOfDefaultImports += 2;
		347	numberOfImports += 2;
		348	}
330	ImportBinding[] resolvedImports = new ImportBinding[numberOfImports];	349	ImportBinding[] resolvedImports = new ImportBinding[numberOfImports];
331	resolvedImports[0] = getDefaultImports()[0];	350	ImportBinding[] defaultImports = getDefaultImports(); // consistent number of default imports is ensured in LookupEnvironment.makeNullAnnotationTypeImports()
332	int index = 1;	351	for (int i = 0; i < numberOfDefaultImports; i++) {
		352	resolvedImports[i] = defaultImports[i];
		353	}
		354
		355	int index = numberOfDefaultImports;
333		356
334	// keep static imports with normal imports until there is a reason to split them up	357	// keep static imports with normal imports until there is a reason to split them up
335	// on demand imports continue to be packages & types. need to check on demand type imports for fields/methods	358	// on demand imports continue to be packages & types. need to check on demand type imports for fields/methods
Lines 613-619 Link Here
613	importBinding = missingObject.fPackage;	636	importBinding = missingObject.fPackage;
614	}	637	}
615		638
616	return this.environment.defaultImports = new ImportBinding[] {new ImportBinding(TypeConstants.JAVA_LANG, true, importBinding, null)};	639	ImportBinding javaLangImport = new ImportBinding(TypeConstants.JAVA_LANG, true, importBinding, null);
		640	ImportBinding[] nullAnnotationImports = this.environment.makeNullAnnotationTypeImports(); // trigger regardless of option below
		641	if (this.environment.globalOptions.defaultImportNullAnnotationTypes) {
		642	ImportBinding[] allDefaultImports = new ImportBinding[nullAnnotationImports.length+1];// java.lang.* + null-annotations
		643	allDefaultImports[0] = javaLangImport;
		644	System.arraycopy(nullAnnotationImports, 0,
		645	allDefaultImports, 1,
		646	nullAnnotationImports.length);
		647	this.environment.defaultImports = allDefaultImports;
		648	} else {
		649	this.environment.defaultImports = new ImportBinding[] {javaLangImport};
		650	}
		651	return this.environment.defaultImports;
617	}	652	}
618	// NOT Public API	653	// NOT Public API
619	public final Binding getImport(char[][] compoundName, boolean onDemand, boolean isStaticImport) {	654	public final Binding getImport(char[][] compoundName, boolean onDemand, boolean isStaticImport) {




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


		return this.nameEnvironment.isPackage(null, name);
	return this.nameEnvironment.isPackage(compoundName, name);
}

private ReferenceBinding makeNullAnnotationType(char[][] compoundName, int typeId) {
	char[][] packageName = CharOperation.subarray(compoundName, 0, compoundName.length-1);
	PackageBinding packageBinding = createPackage(packageName);
	ReferenceBinding typeBinding = packageBinding.getType(compoundName[compoundName.length-1]);
	if (typeBinding != null && typeBinding.isValidBinding())
		this.problemReporter.conflictingTypeEmulation(compoundName); // does not return

	BinaryTypeBinding emulatedType = new BinaryTypeBinding();
	emulatedType.compoundName = compoundName;
	emulatedType.modifiers = ClassFileConstants.AccAnnotation | ClassFileConstants.AccPublic;
	emulatedType.fields = Binding.NO_FIELDS;
	emulatedType.methods = Binding.NO_METHODS;
	emulatedType.memberTypes = Binding.NO_MEMBER_TYPES;
	emulatedType.superclass = getType(TypeConstants.JAVA_LANG_OBJECT);
	emulatedType.superInterfaces = Binding.NO_SUPERINTERFACES;
	emulatedType.fPackage = packageBinding;
	emulatedType.typeVariables = Binding.NO_TYPE_VARIABLES;
	emulatedType.tagBits = TagBits.AreFieldsComplete | TagBits.AreFieldsSorted 
							| TagBits.AreMethodsComplete | TagBits.AreMethodsSorted 
							| TagBits.HasNoMemberTypes | TagBits.TypeVariablesAreConnected
							| TagBits.AnnotationClassRetention 
							| TagBits.AnnotationForMethod | TagBits.AnnotationForParameter ;
	emulatedType.id = typeId;
	
	packageBinding.addType(emulatedType);

	return emulatedType;
}

protected ImportBinding[] makeNullAnnotationTypeImports() {
	char[][] nullableAnnotationName = this.globalOptions.nullableAnnotationName;
	char[][] nonNullAnnotationName = this.globalOptions.nonNullAnnotationName;
	if (nullableAnnotationName == null || nonNullAnnotationName == null) {
		if (this.globalOptions.emulateNullAnnotationTypes || this.globalOptions.defaultImportNullAnnotationTypes)
			// shouldn't happen by construction of CompilerOptions.set(Map)
			this.problemReporter.abortDueToInternalError("Inconsistent null annotation options"); //$NON-NLS-1$
		return new ImportBinding[0];
	}
	// fetch annotation types for emulation and/or default import:
	ReferenceBinding nullableAnnotationType = null;
	ReferenceBinding nonNullAnnotationType = null;
	if (this.globalOptions.emulateNullAnnotationTypes) {
		nullableAnnotationType = makeNullAnnotationType(nullableAnnotationName, TypeIds.T_ConfiguredAnnotationNullable);
		nonNullAnnotationType  = makeNullAnnotationType(nonNullAnnotationName, TypeIds.T_ConfiguredAnnotationNonNull);
	} else if (this.globalOptions.defaultImportNullAnnotationTypes) {
		nullableAnnotationType = getType(nullableAnnotationName);
		nonNullAnnotationType  = getType(nonNullAnnotationName);
	}
	if (this.globalOptions.defaultImportNullAnnotationTypes)
		return new ImportBinding[] {
				new ImportBinding(nullableAnnotationName, false, nullableAnnotationType, null),
				new ImportBinding(nonNullAnnotationName, false, nonNullAnnotationType, null)
		};
	return new ImportBinding[0];
}

// The method verifier is lazily initialized to guarantee the receiver, the compiler & the oracle are ready.
public MethodVerifier methodVerifier() {
	if (this.verifier == null)

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java (+2 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 28-33 Link Here
28	public char[] selector;	29	public char[] selector;
29	public TypeBinding returnType;	30	public TypeBinding returnType;
30	public TypeBinding[] parameters;	31	public TypeBinding[] parameters;
		32	public Boolean[] parameterNonNullness; // TRUE means @NonNull declared, FALSE means @Nullable declared, null means nothing declared
31	public ReferenceBinding[] thrownExceptions;	33	public ReferenceBinding[] thrownExceptions;
32	public ReferenceBinding declaringClass;	34	public ReferenceBinding declaringClass;
33	public TypeVariableBinding[] typeVariables = Binding.NO_TYPE_VARIABLES;	35	public TypeVariableBinding[] typeVariables = Binding.NO_TYPE_VARIABLES;

Lines 8-13 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java (-1 / +5 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Benjamin Muskalla - Contribution for bug 239066	10	* Benjamin Muskalla - Contribution for bug 239066
		11	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.jdt.internal.compiler.lookup;	13	package org.eclipse.jdt.internal.compiler.lookup;
13		14
Lines 152-157 Link Here
152	// interface I { @Override Object clone(); } does not override Object#clone()	153	// interface I { @Override Object clone(); } does not override Object#clone()
153	currentMethod.modifiers \|= ExtraCompilerModifiers.AccOverriding;	154	currentMethod.modifiers \|= ExtraCompilerModifiers.AccOverriding;
154	}	155	}
		156	checkNullContractCompatibility(currentMethod, inheritedMethod);
155		157
156	if (!areReturnTypesCompatible(currentMethod, inheritedMethod)	158	if (!areReturnTypesCompatible(currentMethod, inheritedMethod)
157	&& (currentMethod.returnType.tagBits & TagBits.HasMissingType) == 0) {	159	&& (currentMethod.returnType.tagBits & TagBits.HasMissingType) == 0) {
Lines 184-190 Link Here
184	checkForBridgeMethod(currentMethod, inheritedMethod, allInheritedMethods);	186	checkForBridgeMethod(currentMethod, inheritedMethod, allInheritedMethods);
185	}	187	}
186	}	188	}
187		189	protected void checkNullContractCompatibility(MethodBinding currentMethod, MethodBinding inheritedMethod) {
		190	// nothing to do here. Real action happens at 1.5+
		191	}
188	public void reportRawReferences(MethodBinding currentMethod, MethodBinding inheritedMethod) {	192	public void reportRawReferences(MethodBinding currentMethod, MethodBinding inheritedMethod) {
189	// nothing to do here. Real action happens at 1.5+	193	// nothing to do here. Real action happens at 1.5+
190	}	194	}




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;


	return false;
}

protected void checkNullContractCompatibility(MethodBinding currentMethod, MethodBinding inheritedMethod) {
	if ((inheritedMethod.tagBits & TagBits.AnnotationNonNull) != 0) {
		if ((currentMethod.tagBits & TagBits.AnnotationNullable) != 0) {
			AbstractMethodDeclaration methodDecl = currentMethod.sourceMethod();
			this.type.scope.problemReporter().illegalRedefinitionToNullableReturn(methodDecl, inheritedMethod.declaringClass, 
																			this.environment.globalOptions.nonNullAnnotationName);
		}
	}
	if ((currentMethod.tagBits & (TagBits.AnnotationNonNull|TagBits.AnnotationNullable)) == 0)
		currentMethod.tagBits |= (inheritedMethod.tagBits & (TagBits.AnnotationNonNull|TagBits.AnnotationNullable));

	if (inheritedMethod.parameterNonNullness != null) {
		AbstractMethodDeclaration methodDecl = currentMethod.sourceMethod();
		for (int i = 0; i < inheritedMethod.parameterNonNullness.length; i++) {
			if (inheritedMethod.parameterNonNullness[i] == Boolean.FALSE) { // promised to accept @Nullable
				if (currentMethod.parameterNonNullness == null)
					currentMethod.parameterNonNullness = new Boolean[currentMethod.parameters.length];
				if (currentMethod.parameterNonNullness[i] == Boolean.TRUE) {
					this.type.scope.problemReporter().illegalRedefinitionToNonNullParameter(methodDecl.arguments[i], 
																			inheritedMethod.declaringClass, 
																			this.environment.globalOptions.nullableAnnotationName);
					continue;
				} 
			}
			if (currentMethod.parameterNonNullness[i] == null && inheritedMethod.parameterNonNullness[i] != null) {
				currentMethod.parameterNonNullness[i] = inheritedMethod.parameterNonNullness[i];
				methodDecl.arguments[i].binding.tagBits |= (currentMethod.parameterNonNullness[i].booleanValue())
								? TagBits.AnnotationNonNull : TagBits.AnnotationNullable;
			}
		}
	}
}

void reportRawReferences() {
	CompilerOptions compilerOptions = this.type.scope.compilerOptions();
	if (compilerOptions.sourceLevel < ClassFileConstants.JDK1_5 // shouldn't whine at all

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (-2 / +5 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 1408-1416 Link Here
1408	}	1409	}
1409	}	1410	}
1410	// only assign parameters if no problems are found	1411	// only assign parameters if no problems are found
1411	if (!foundArgProblem) {	1412	if (foundArgProblem) {
		1413	methodDecl.binding = null;
		1414	} else {
1412	method.parameters = newParameters;	1415	method.parameters = newParameters;
1413	}	1416	}
		1417	methodDecl.bindArguments();
1414	}	1418	}
1415		1419
1416	boolean foundReturnTypeProblem = false;	1420	boolean foundReturnTypeProblem = false;
Lines 1453-1459 Link Here
1453	}	1457	}
1454	}	1458	}
1455	if (foundArgProblem) {	1459	if (foundArgProblem) {
1456	methodDecl.binding = null;
1457	method.parameters = Binding.NO_PARAMETERS; // see 107004	1460	method.parameters = Binding.NO_PARAMETERS; // see 107004
1458	// nullify type parameter bindings as well as they have a backpointer to the method binding	1461	// nullify type parameter bindings as well as they have a backpointer to the method binding
1459	// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=81134)	1462	// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=81134)

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TagBits.java (-3 / +7 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 119-128 Link Here
119	long AnnotationInherited = ASTNode.Bit49L;	120	long AnnotationInherited = ASTNode.Bit49L;
120	long AnnotationOverride = ASTNode.Bit50L;	121	long AnnotationOverride = ASTNode.Bit50L;
121	long AnnotationSuppressWarnings = ASTNode.Bit51L;	122	long AnnotationSuppressWarnings = ASTNode.Bit51L;
122	long AllStandardAnnotationsMask = AnnotationTargetMASK \| AnnotationRetentionMASK \| AnnotationDeprecated \| AnnotationDocumented \| AnnotationInherited \| AnnotationOverride \| AnnotationSuppressWarnings;	123	long AnnotationNullable = ASTNode.Bit52L;
		124	long AnnotationNonNull = ASTNode.Bit53L;
		125	long AllStandardAnnotationsMask = AnnotationTargetMASK \| AnnotationRetentionMASK \| AnnotationDeprecated \| AnnotationDocumented
		126	\| AnnotationInherited \| AnnotationOverride \| AnnotationSuppressWarnings \| AnnotationNullable \| AnnotationNonNull;
123		127
124	long DefaultValueResolved = ASTNode.Bit52L;	128	long DefaultValueResolved = ASTNode.Bit54L;
125		129
126	// set when type contains non-private constructor(s)	130	// set when type contains non-private constructor(s)
127	long HasNonPrivateConstructor = ASTNode.Bit53L;	131	long HasNonPrivateConstructor = ASTNode.Bit55L;
128	}	132	}

Lines 7-12 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeIds.java (+4 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
10	*******************************************************************************/	11	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	12	package org.eclipse.jdt.internal.compiler.lookup;
12		13
Lines 89-94 Link Here
89		90
90	final int T_JavaUtilCollection = 59;	91	final int T_JavaUtilCollection = 59;
91		92
		93	final int T_ConfiguredAnnotationNullable = 60;
		94	final int T_ConfiguredAnnotationNonNull = 61;
		95
92	final int NoId = Integer.MAX_VALUE;	96	final int NoId = Integer.MAX_VALUE;
93		97
94	public static final int IMPLICIT_CONVERSION_MASK = 0xFF;	98	public static final int IMPLICIT_CONVERSION_MASK = 0xFF;




 *     IBM Corporation - initial API and implementation
 *     Benjamin Muskalla - Contribution for bug 239066
 *     Stephan Herrmann  - Contribution for bug 236385
 *     Stephan Herrmann -  Contribution for bug 186342 - [compiler][null]Using annotations for null checking
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.problem;


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;

		case IProblem.NullLocalVariableInstanceofYieldsFalse:
			return CompilerOptions.RedundantNullCheck;

		case IProblem.DefiniteNullFromNonNullMethod:
		case IProblem.DefiniteNullToNonnullParameter:
		case IProblem.IllegalRedefinitionToNullableReturn:
		case IProblem.IllegalRedefinitionToNonNullParameter:
			return CompilerOptions.NullContractViolation;
		case IProblem.PotentialNullFromNonNullMethod:
		case IProblem.PotentialNullToNonnullParameter:
			return CompilerOptions.PotentialNullContractViolation;
		case IProblem.NonNullParameterInsufficientInfo:
		case IProblem.NonNullReturnInsufficientInfo:
			return CompilerOptions.NullContractInsufficientInfo;

		case IProblem.BoxingConversion :
		case IProblem.UnboxingConversion :
			return CompilerOptions.AutoBoxing;

			case CompilerOptions.NullReference :
			case CompilerOptions.PotentialNullReference :
			case CompilerOptions.RedundantNullCheck :
			case CompilerOptions.NullContractViolation :
			case CompilerOptions.PotentialNullContractViolation :
			case CompilerOptions.NullContractInsufficientInfo :
			case CompilerOptions.IncompleteEnumSwitch :
			case CompilerOptions.FallthroughCase :
			case CompilerOptions.OverridingMethodWithoutSuperInvocation :

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

		default :

		importRef.sourceStart,
		importRef.sourceEnd);
}
public void conflictingTypeEmulation(char[][] compoundName) {
	String[] arguments = new String[] {CharOperation.toString(compoundName)};
	this.handle(
		IProblem.ConflictingTypeEmulation,
		arguments,
		arguments,
		ProblemSeverities.Error | ProblemSeverities.Abort | ProblemSeverities.Fatal, // not configurable
		0, 0);	
}
public void constantOutOfRange(Literal literal, TypeBinding literalType) {
	String[] arguments = new String[] {new String(literalType.readableName()), new String(literal.source())};
	this.handle(

		qualifiedTypeReference.sourceStart,
		qualifiedTypeReference.sourceEnd);
}
public void illegalRedefinitionToNonNullParameter(Argument argument, ReferenceBinding declaringClass, char[][] nullableAnnotationName) {
	this.handle(
			IProblem.IllegalRedefinitionToNonNullParameter, 
			new String[] { new String(declaringClass.readableName()), CharOperation.toString(nullableAnnotationName)},
			new String[] { new String(declaringClass.shortReadableName()), new String(nullableAnnotationName[nullableAnnotationName.length-1])},
			argument.sourceStart, 
			argument.sourceEnd);
}
public void illegalRedefinitionToNullableReturn(AbstractMethodDeclaration methodDecl, ReferenceBinding declaringClass, char[][] nonNullAnnotationName) {
	this.handle(
		IProblem.IllegalRedefinitionToNullableReturn, 
		new String[] { new String(declaringClass.readableName()), CharOperation.toString(nonNullAnnotationName)},
		new String[] { new String(declaringClass.shortReadableName()), new String(nonNullAnnotationName[nonNullAnnotationName.length-1])},
		methodDecl.sourceStart, 
		methodDecl.sourceEnd);	
}
public void illegalStaticModifierForMemberType(SourceTypeBinding type) {
	String[] arguments = new String[] {new String(type.sourceName())};
	this.handle(

		caseStatement.sourceStart,
		caseStatement.sourceEnd);
}
public void possiblyNullFromNonNullMethod(ReturnStatement returnStatement, int nullStatus, char[] annotationName) {
	int problemId = IProblem.NonNullReturnInsufficientInfo;
	if ((nullStatus & FlowInfo.NULL) != 0)
		problemId = IProblem.DefiniteNullFromNonNullMethod;
	if ((nullStatus & FlowInfo.POTENTIALLY_NULL) != 0)
		problemId = IProblem.PotentialNullFromNonNullMethod;
	String[] arguments = new String[] { String.valueOf(annotationName) };
	this.handle(
		problemId,
		arguments,
		arguments,
		returnStatement.sourceStart,
		returnStatement.sourceEnd);
}
public void possiblyNullToNonNullParameter(Expression argument, int nullStatus, char[] annotationName) {
	int problemId = IProblem.NonNullParameterInsufficientInfo;
	if ((nullStatus & FlowInfo.NULL) != 0)
		problemId = IProblem.DefiniteNullToNonnullParameter;
	else if ((nullStatus & FlowInfo.POTENTIALLY_NULL) != 0)
		problemId = IProblem.PotentialNullToNonnullParameter;
	String[] arguments = new String[] { String.valueOf(annotationName) };
	this.handle(
		problemId,
		arguments,
		arguments,
		argument.sourceStart,
		argument.sourceEnd);
}
public void publicClassMustMatchFileName(CompilationUnitDeclaration compUnitDecl, TypeDeclaration typeDecl) {
	this.referenceContext = typeDecl; // report the problem against the type not the entire compilation unit
	String[] arguments = new String[] {new String(compUnitDecl.getFileName()), new String(typeDecl.name)};

Lines 8-14 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (-1 / +14 lines)
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	# Benjamin Muskalla - Contribution for bug 239066	10	# Benjamin Muskalla - Contribution for bug 239066
11	# Stephan Herrmann <stephan@cs.tu-berlin.de> - Contribution for bug 185682 - Increment/decrement operators mark local variables as read	11	# Stephan Herrmann <stephan@cs.tu-berlin.de> - Contributions for
		12	# bug 185682 - Increment/decrement operators mark local variables as read
		13	# bug 186342 - [compiler][null]Using annotations for null checking
12	###############################################################################	14	###############################################################################
13	0 = {0}	15	0 = {0}
14	1 = super cannot be used in java.lang.Object	16	1 = super cannot be used in java.lang.Object
Lines 619-624 Link Here
619	858 = The parameterized constructor <{3}>{0}({1}) of type {2} is not applicable for the arguments ({4})	621	858 = The parameterized constructor <{3}>{0}({1}) of type {2} is not applicable for the arguments ({4})
620	859 = The constructor {0}({1}) of raw type {2} is no longer generic; it cannot be parameterized with arguments <{3}>	622	859 = The constructor {0}({1}) of raw type {2} is no longer generic; it cannot be parameterized with arguments <{3}>
621		623
		624	### NULL ANNOTATIONS
		625	880 = Null contract violation: returning null from a method declared as @{0}.
		626	881 = Potential null contract violation: return value can be null but method is declared as @{0}.
		627	882 = Potential null contract violation: insufficient nullness information regarding return value while the method is declared as @{0}.
		628	883 = Null contract violation: passing null to a parameter declared as @{0}.
		629	884 = Potential null contract violation: potentially passing null to a parameter declared as @{0}.
		630	885 = Potential null contract violation: insufficient nullness information regarding a value that is passed to a parameter declared as @{0}.
		631	886 = Buildpath problem: emulation of type {0} is requested (for null annotations) but a type of this name exists on the build path.
		632	887 = Cannot relax null contract for method return, inherited method from {0} is declared as @{1}.
		633	888 = Cannot tighten null contract for parameter, inherited method from {0} declares the parameter as @{1}.
		634
622	### ELABORATIONS	635	### ELABORATIONS
623	## Access restrictions	636	## Access restrictions
624	78592 = The type {1} is not accessible due to restriction on classpath entry {0}	637	78592 = The type {1} is not accessible due to restriction on classpath entry {0}

Lines 83-88 Link Here

(-)model/org/eclipse/jdt/core/JavaCore.java (+77 lines)
83	* Benjamin Muskalla - added COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD	83	* Benjamin Muskalla - added COMPILER_PB_MISSING_SYNCHRONIZED_ON_INHERITED_METHOD
84	* Stephan Herrmann - added COMPILER_PB_UNUSED_OBJECT_ALLOCATION	84	* Stephan Herrmann - added COMPILER_PB_UNUSED_OBJECT_ALLOCATION
85	* Stephan Herrmann - added COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS	85	* Stephan Herrmann - added COMPILER_PB_SUPPRESS_OPTIONAL_ERRORS
		86	* Stephan Herrmann - added COMPILER_PB_NULL_CONTRACT_VIOLATION
		87	* COMPILER_PB_POTENTIAL_NULL_CONTRACT_VIOLATION
		88	* COMPILER_PB_NULL_CONTRACT_INSUFFICIENT_INFO
86	*******************************************************************************/	89	*******************************************************************************/
87		90
88	package org.eclipse.jdt.core;	91	package org.eclipse.jdt.core;
Lines 1576-1581 Link Here
1576	*/	1579	*/
1577	public static final String COMPILER_PB_POTENTIAL_NULL_REFERENCE = PLUGIN_ID + ".compiler.problem.potentialNullReference"; //$NON-NLS-1$	1580	public static final String COMPILER_PB_POTENTIAL_NULL_REFERENCE = PLUGIN_ID + ".compiler.problem.potentialNullReference"; //$NON-NLS-1$
1578	/**	1581	/**
		1582	* Compiler option ID: Reporting Violations of Null Contracts.
		1583	* <p>When enabled, the compiler will issue an error or a warning whenever one of the
		1584	* following situations is detected:
		1585	* <ol>
		1586	* <li>a method declared with a nonnull annotation returns an expression that is
		1587	* statically known to evaluate to a null value</li>
		1588	* <li>an expression that is statically known to evaluate to a null value is passed
		1589	* as an argument in a method call where the corresponding parameter of the called
		1590	* method is declared with a nonnull annotation.</li>
		1591	* <li>a method that overrides an inherited method declared with a nonnull annotation
		1592	* tries to relax that contract by specifying a nullable annotation
		1593	* (prohibition of contravariant return).</li>
		1594	* <li>a method that overrides an inherited method which has a nullable declaration
		1595	* for at least one of its parameters, tries to tighten that null contract by
		1596	* specifying a nonnull annotation for its corresponding parameter
		1597	* (prohibition of covariant parameters).</li>
		1598	* </ol>
		1599	* </p>
		1600	* <dl>
		1601	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullContractViolation"</code></dd>
		1602	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1603	* <dt>Default:</dt><dd><code>"error"</code></dd>
		1604	* </dl>
		1605	* @since 3.7
		1606	* @category CompilerOptionID
		1607	*/
		1608	public static final String COMPILER_PB_NULL_CONTRACT_VIOLATION = PLUGIN_ID + ".compiler.problem.nullContractViolation"; //$NON-NLS-1$
		1609	/**
		1610	* Compiler option ID: Reporting Potential Violations of Null Contracts.
		1611	* <p>When enabled, the compiler will issue an error or a warning whenever one of the
		1612	* following situations is detected:
		1613	* <ol>
		1614	* <li>a method declared with a nonnull annotation returns an expression that is
		1615	* statically known to evaluate to a null value on some flow</li>
		1616	* <li>an expression that is statically known to evaluate to a null value on some flow
		1617	* is passed as an argument in a method call where the corresponding parameter of
		1618	* the called method is declared with a nonnull annotation.</li>
		1619	* </ol>
		1620	* </p>
		1621	* <dl>
		1622	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.potentialNullContractViolation"</code></dd>
		1623	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
		1624	* <dt>Default:</dt><dd><code>"warning"</code></dd>
		1625	* </dl>
		1626	* @since 3.7
		1627	* @category CompilerOptionID
		1628	*/
		1629	public static final String COMPILER_PB_POTENTIAL_NULL_CONTRACT_VIOLATION = PLUGIN_ID + ".compiler.problem.potentialNullContractViolation"; //$NON-NLS-1$
		1630	/**
		1631	* Compiler option ID: Reporting Insufficient Information for Analysing Adherence to Null Contracts.
		1632	* <p>When enabled, the compiler will issue an error or a warning whenever one of the
		1633	* following situations is detected:
		1634	* <ol>
		1635	* <li>a method declared with a nonnull annotation returns an expression for which
		1636	* insufficient nullness information is available for statically proving that no
		1637	* flow will pass a null value at runtime.</li>
		1638	* <li>an expression for which insufficient nullness information is available for
		1639	* statically proving that it will never evaluate to a null value at runtime
		1640	* is passed as an argument in a method call where the corresponding parameter of
		1641	* the called method is declared with a nonnull annotation.</li>
		1642	* </ol>
		1643	* Insufficient nullness information is usually a consequence of using other unannotated
		1644	* variables or methods.
		1645	* </p>
1646	* <dl>
1647	* <dt>Option id:</dt><dd><code>"org.eclipse.jdt.core.compiler.problem.nullContractInsufficientInfo"</code></dd>
1648	* <dt>Possible values:</dt><dd><code>{ "error", "warning", "ignore" }</code></dd>
1649	* <dt>Default:</dt><dd><code>"warning"</code></dd>
1650	* </dl>
1651	* @since 3.7
1652	* @category CompilerOptionID
1653	*/
1654	public static final String COMPILER_PB_NULL_CONTRACT_INSUFFICIENT_INFO = PLUGIN_ID + ".compiler.problem.nullContractInsufficientInfo"; //$NON-NLS-1$
1655	/**
1579	* Compiler option ID: Reporting Redundant Null Check.	1656	* Compiler option ID: Reporting Redundant Null Check.
1580	* <p>When enabled, the compiler will issue an error or a warning whenever a	1657	* <p>When enabled, the compiler will issue an error or a warning whenever a
1581	* variable that is statically known to hold a null or a non-null value	1658	* variable that is statically known to hold a null or a non-null value

Lines 10-16 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java (-2 / +89 lines)
10	* Benjamin Muskalla - Contribution for bug 239066	10	* Benjamin Muskalla - Contribution for bug 239066
11	* Stephan Herrmann - Contribution for bug 236385	11	* Stephan Herrmann - Contribution for bug 236385
12	* Stephan Herrmann - Contribution for bug 295551	12	* Stephan Herrmann - Contribution for bug 295551
13	* Stephan Herrmann <stephan@cs.tu-berlin.de> - Contribution for bug 185682 - Increment/decrement operators mark local variables as read	13	* Stephan Herrmann <stephan@cs.tu-berlin.de> - Contributions for
		14	* bug 185682 - Increment/decrement operators mark local variables as read
		15	* bug 186342 - [compiler][null]Using annotations for null checking
14	*******************************************************************************/	16	*******************************************************************************/
15	package org.eclipse.jdt.core.tests.compiler.regression;	17	package org.eclipse.jdt.core.tests.compiler.regression;
16		18
Lines 48-54 Link Here
48	private static final Main MAIN = new Main(null/outWriter/, null/errWriter/, false/systemExit/, null/options/, null/progress/);	50	private static final Main MAIN = new Main(null/outWriter/, null/errWriter/, false/systemExit/, null/options/, null/progress/);
49		51
50	static {	52	static {
51	// TESTS_NAMES = new String[] { "test295_warn_options" };	53	// TESTS_NAMES = new String[] { "testNullAnnotations" };
52	// TESTS_NUMBERS = new int[] { 306 };	54	// TESTS_NUMBERS = new int[] { 306 };
53	// TESTS_RANGE = new int[] { 298, -1 };	55	// TESTS_RANGE = new int[] { 298, -1 };
54	}	56	}
Lines 1589-1594 Link Here
1589	" -classNames <className1[,className2,...]>\n" +	1591	" -classNames <className1[,className2,...]>\n" +
1590	" qualified names of binary classes to process\n" +	1592	" qualified names of binary classes to process\n" +
1591	" \n" +	1593	" \n" +
		1594	" Null annotation options:\n" +
		1595	" -nullAnnotations:<suboptions>\n" +
		1596	" enable use of annotations for specifying null contracts;\n" +
		1597	" <suboptions> is a non-empty, comma-separated list of:\n" +
		1598	" nullable=<typename>\n" +
		1599	" specifies the fully qualified name of an annotation type\n" +
		1600	" to be used for marking types whose values include null\n" +
		1601	" nonnull=<typename>\n" +
		1602	" specifies the fully qualified name of an annotation type\n" +
		1603	" to be used for marking types whose values cannot be null\n" +
		1604	" emulate tells the compiler to emulate the above annotation types\n" +
		1605	" although they do not exist on the classpath\n" +
		1606	" import tells the compiler to import the above annotation types\n" +
		1607	" without specific mention in the sources such that their\n" +
		1608	" simple names can be used without explicit imports\n" +
		1609	" \n" +
1592	" Advanced options:\n" +	1610	" Advanced options:\n" +
1593	" @<file> read command line arguments from file\n" +	1611	" @<file> read command line arguments from file\n" +
1594	" -maxProblems <n> max number of problems per compilation unit (100 by\n" +	1612	" -maxProblems <n> max number of problems per compilation unit (100 by\n" +
Lines 1793-1798 Link Here
1793	" <argument value=\"---OUTPUT_DIR_PLACEHOLDER---\"/>\n" +	1811	" <argument value=\"---OUTPUT_DIR_PLACEHOLDER---\"/>\n" +
1794	" </command_line>\n" +	1812	" </command_line>\n" +
1795	" <options>\n" +	1813	" <options>\n" +
		1814	" <option key=\"org.eclipse.jdt.core.compiler.annotation.defaultImport\" value=\"disabled\"/>\n" +
		1815	" <option key=\"org.eclipse.jdt.core.compiler.annotation.emulate\" value=\"disabled\"/>\n" +
1796	" <option key=\"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode\" value=\"disabled\"/>\n" +	1816	" <option key=\"org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode\" value=\"disabled\"/>\n" +
1797	" <option key=\"org.eclipse.jdt.core.compiler.codegen.targetPlatform\" value=\"1.5\"/>\n" +	1817	" <option key=\"org.eclipse.jdt.core.compiler.codegen.targetPlatform\" value=\"1.5\"/>\n" +
1798	" <option key=\"org.eclipse.jdt.core.compiler.codegen.unusedLocal\" value=\"optimize out\"/>\n" +	1818	" <option key=\"org.eclipse.jdt.core.compiler.codegen.unusedLocal\" value=\"optimize out\"/>\n" +
Lines 1850-1860 Link Here
1850	" <option key=\"org.eclipse.jdt.core.compiler.problem.noEffectAssignment\" value=\"warning\"/>\n" +	1870	" <option key=\"org.eclipse.jdt.core.compiler.problem.noEffectAssignment\" value=\"warning\"/>\n" +
1851	" <option key=\"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion\" value=\"warning\"/>\n" +	1871	" <option key=\"org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion\" value=\"warning\"/>\n" +
1852	" <option key=\"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral\" value=\"ignore\"/>\n" +	1872	" <option key=\"org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral\" value=\"ignore\"/>\n" +
		1873	" <option key=\"org.eclipse.jdt.core.compiler.problem.nullContractInsufficientInfo\" value=\"warning\"/>\n" +
		1874	" <option key=\"org.eclipse.jdt.core.compiler.problem.nullContractViolation\" value=\"error\"/>\n" +
1853	" <option key=\"org.eclipse.jdt.core.compiler.problem.nullReference\" value=\"warning\"/>\n" +	1875	" <option key=\"org.eclipse.jdt.core.compiler.problem.nullReference\" value=\"warning\"/>\n" +
1854	" <option key=\"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation\" value=\"ignore\"/>\n" +	1876	" <option key=\"org.eclipse.jdt.core.compiler.problem.overridingMethodWithoutSuperInvocation\" value=\"ignore\"/>\n" +
1855	" <option key=\"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod\" value=\"warning\"/>\n" +	1877	" <option key=\"org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod\" value=\"warning\"/>\n" +
1856	" <option key=\"org.eclipse.jdt.core.compiler.problem.parameterAssignment\" value=\"ignore\"/>\n" +	1878	" <option key=\"org.eclipse.jdt.core.compiler.problem.parameterAssignment\" value=\"ignore\"/>\n" +
1857	" <option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\n" +	1879	" <option key=\"org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment\" value=\"ignore\"/>\n" +
		1880	" <option key=\"org.eclipse.jdt.core.compiler.problem.potentialNullContractViolation\" value=\"warning\"/>\n" +
1858	" <option key=\"org.eclipse.jdt.core.compiler.problem.potentialNullReference\" value=\"ignore\"/>\n" +	1881	" <option key=\"org.eclipse.jdt.core.compiler.problem.potentialNullReference\" value=\"ignore\"/>\n" +
1859	" <option key=\"org.eclipse.jdt.core.compiler.problem.rawTypeReference\" value=\"warning\"/>\n" +	1882	" <option key=\"org.eclipse.jdt.core.compiler.problem.rawTypeReference\" value=\"warning\"/>\n" +
1860	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantNullCheck\" value=\"ignore\"/>\n" +	1883	" <option key=\"org.eclipse.jdt.core.compiler.problem.redundantNullCheck\" value=\"ignore\"/>\n" +
Lines 12264-12267 Link Here
12264	"3 problems (1 error, 2 warnings)",	12287	"3 problems (1 error, 2 warnings)",
12265	true);	12288	true);
12266	}	12289	}
		12290	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=186342 -- minimal options passed
		12291	public void testNullAnnotations1() {
		12292	this.runNegativeTest(
		12293	new String[] {
		12294	"X.java",
		12295	"public class X {\n" +
		12296	" @org.eclipse.jdt.annotation.NonNull Object foo(boolean b) {\n" +
		12297	" return null;\n" +
		12298	" }\n" +
		12299	"}\n"
		12300	},
		12301	"\"" + OUTPUT_DIR + File.separator + "X.java\""
		12302	+ " -1.5 -nullAnnotations:emulate -d \"" + OUTPUT_DIR + "\"",
		12303	"",
		12304	"----------\n" +
		12305	"1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java (at line 3)\n" +
		12306	" return null;\n" +
		12307	" ^^^^^^^^^^^^\n" +
		12308	"Null contract violation: returning null from a method declared as @NonNull.\n" +
		12309	"----------\n" +
		12310	"1 problem (1 error)",
		12311	true);
		12312	}
		12313	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=186342 -- full options passed
		12314	public void testNullAnnotations2() {
		12315	this.runNegativeTest(
		12316	new String[] {
		12317	"X.java",
		12318	"public class X {\n" +
		12319	" @NichtNull Object foo(boolean b) {\n" +
		12320	" return null;\n" +
		12321	" }\n" +
		12322	"}\n"
		12323	},
		12324	"\"" + OUTPUT_DIR + File.separator + "X.java\""
		12325	+ " -1.5 -nullAnnotations:nullable=org.foo.Nullish,emulate,import,nonnull=de.foo.NichtNull -d \"" + OUTPUT_DIR + "\"",
		12326	"",
		12327	"----------\n" +
		12328	"1. ERROR in ---OUTPUT_DIR_PLACEHOLDER---/X.java (at line 3)\n" +
		12329	" return null;\n" +
		12330	" ^^^^^^^^^^^^\n" +
		12331	"Null contract violation: returning null from a method declared as @NichtNull.\n" +
		12332	"----------\n" +
		12333	"1 problem (1 error)",
		12334	true);
		12335	}
		12336	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=186342 -- unrecognized sub-option
		12337	public void testNullAnnotations3() {
		12338	this.runNegativeTest(
		12339	new String[] {
		12340	"X.java",
		12341	"public class X {\n" +
		12342	" @NichtNull Object foo(boolean b) {\n" +
		12343	" return null;\n" +
		12344	" }\n" +
		12345	"}\n"
		12346	},
		12347	"\"" + OUTPUT_DIR + File.separator + "X.java\""
		12348	+ " -1.5 -nullAnnotations:wrong -d \"" + OUTPUT_DIR + "\"",
		12349	"",
		12350	"Unrecognized sub-option of -nullAnnotations: wrong,\n" +
		12351	"legal values are nullable=.., nonnull=.., emulate and import\n",
		12352	true);
		12353	}
12267	}	12354	}




/*******************************************************************************
 * Copyright (c) 2010 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 <sherrmann@gk-software.com> - initial API and implementation 
 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;

import java.util.Map;

import junit.framework.Test;

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

public class NullAnnotationTest extends AbstractComparableTest {

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

// Static initializer to specify tests subset using TESTS_* static variables
// All specified tests which does not belong to the class are skipped...
// Only the highest compliance level is run; add the VM argument
// -Dcompliance=1.4 (for example) to lower it if needed
static {
//		TESTS_NAMES = new String[] { "test_nonnull_paramter_005" };
//		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;
}

// 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);
		
		// leave new options at these defaults:
//		defaultOptions.put(CompilerOptions.OPTION_ReportNullContractViolation, CompilerOptions.ERROR);
//		defaultOptions.put(CompilerOptions.OPTION_ReportPotentialNullContractViolation, CompilerOptions.WARNING);
//		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");
		defaultOptions.put(CompilerOptions.OPTION_EmulateNullAnnotationTypes, CompilerOptions.ENABLED);
		defaultOptions.put(CompilerOptions.OPTION_DefaultImportNullAnnotationTypes, CompilerOptions.ENABLED);
    }
    return defaultOptions;
}

// a non-null argument is checked for null
public void test_nonnull_parameter_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "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 3)\n" + 
		"	if (o != null)\n" + 
		"	    ^\n" + 
		"Redundant null check: The variable o cannot be null at this location\n" + 
		"----------\n",
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a non-null argument is dereferenced without a check
public void test_nonnull_parameter_002() {
	runConformTest(
		new String[] {
			"X.java",
			  "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");
}
// a nullable argument is dereferenced without a check
public void test_nullable_paramter_003() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "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 3)\n" + 
		"	System.out.print(o.toString());\n" + 
		"	                 ^\n" + 
		"Potential null pointer access: The variable o may be null at this location\n" + 
		"----------\n",
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// passing null to nonnull parameter 
public void test_nonnull_paramter_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			  "public class X {\n" +
			  "    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 6)\n" + 
		"	foo(null);\n" + 
		"	    ^^^^\n" + 
		"Null contract violation: passing null to a parameter declared as @NonNull.\n" + 
		"----------\n",
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// passing potential null to nonnull parameter 
public void test_nonnull_paramter_002() {
	runConformTest(
			new String[] {
				"Lib.java",
				"public class Lib {\n" +
				"    void setObject(@NonNull Object o) { }\n" +
				"}\n"
			});
	runConformTest(
		false /* flush output directory */,
		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 /* no class libraries */,
		null /* no custom options */,
		"----------\n" + 
		"1. WARNING in X.java (at line 5)\n" + 
		"	l.setObject(o);\n" + 
		"	            ^\n" + 
		"Potential null contract violation: potentially passing null to a parameter declared as @NonNull.\n" + 
		"----------\n",
		"",/* expected output */
		"",/* expected error */
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// passing unknown value to nonnull parameter 
public void test_nonnull_paramter_003() {
	runConformTest(
			new String[] {
				"Lib.java",
				"public class Lib {\n" +
				"    void setObject(@NonNull Object o) { }\n" +
				"}\n"
			});
	runConformTest(
		false /* flush output directory */,
		new String[] {
			"X.java",
			  "public class X {\n" +
			  "    void bar(Lib l, Object o) {\n" +
			  "        l.setObject(o);\n" +
			  "    }\n" +
			  "}\n"},
		null /* no class libraries */,
		null /* no custom options */,
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	l.setObject(o);\n" + 
		"	            ^\n" + 
		"Potential null contract violation: insufficient nullness information regarding a value that is passed to a parameter declared as @NonNull.\n" + 
		"----------\n",
		"",/* expected output */
		"",/* expected error */
	    JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a method tries to tighten the null contract, super declares parameter as @Nullable
public void test_nonnull_paramter_004() {
	runConformTest(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    void foo(@Nullable Object o) { }\n" +
			"}\n"
		});
	runNegativeTest(
		false /* flush output directory */,
		new String[] {
			"X.java",
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    void foo(@NonNull Object o) { System.out.print(o.toString()); }\n" +
			"}\n"
		},
		// compiler options
		null /* no class libraries */,
		null /* no custom options */,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	void foo(@NonNull Object o) { System.out.print(o.toString()); }\n" + 
		"	                         ^\n" + 
		"Cannot tighten null contract for parameter, inherited method from Lib declares the parameter as @Nullable.\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a method body fails to handle the inherited null contract, super declares parameter as @Nullable
public void test_nonnull_paramter_005() {
	runConformTest(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    void foo(@Nullable Object o) { }\n" +
			"}\n"
		});
	runNegativeTest(
		false /* flush output directory */,
		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"
		},
		// compiler options
		null /* no class libraries */,
		null /* no custom options */,
		"----------\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",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

// a nullable return value is dereferenced without a check
public void test_nullable_return_001() {
	runNegativeTest(
		new String[] {
			"X.java",
			"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 5)\n" + 
		"	System.out.print(o.toString());\n" + 
		"	                 ^\n" + 
		"Potential null pointer access: The variable o may be null at this location\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a nullable return value is dereferenced without a check, method is read from .class file
public void test_nullable_return_002() {
	runConformTest(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"}\n"
		});
	runNegativeTest(
		false /* flush output directory */,
		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"
		},
		// compiler options
		null /* no class libraries */,
		null /* no custom options */,
		"----------\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",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a non-null return value is checked for null, method is read from .class file
public void test_nonnull_return_001() {
	runConformTest(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		});
	runNegativeTest(
		false /* flush output directory */,
		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"
		},
		// compiler options
		null /* no class libraries */,
		null /* no custom options */,
		"----------\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",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a non-null method returns null
public void test_nonnull_return_003() {
	runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    @NonNull Object getObject(boolean b) {\n" +
			"        if (b)\n" +
			"            return null;\n" + // definite contract violation despite enclosing "if"
			"        return new Object();\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 4)\n" + 
		"	return null;\n" + 
		"	^^^^^^^^^^^^\n" + 
		"Null contract violation: returning null from a method declared as @NonNull.\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a non-null method potentially returns null
public void test_nonnull_return_004() {
	runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    @NonNull Object getObject(@Nullable Object o) {\n" +
			"        return o;\n" + // potential contract violation because 'o' is only potentially null
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	return o;\n" + 
		"	^^^^^^^^^\n" + 
		"Potential null contract violation: return value can be null but method is declared as @NonNull.\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);
	runConformTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    @NonNull Object getObject(@NonNull Object o) {\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		"",
		null/*classLibs*/,
		true/*shouldFlushOutputDirectory*/,
		null/*vmArguments*/,
		customOptions,
		null/*compilerRequestor*/);
}
//a non-null method has insufficient nullness info for its return value
public void test_nonnull_return_006() {
	runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" +
			"    @NonNull Object getObject(Object o) {\n" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	return o;\n" + 
		"	^^^^^^^^^\n" + 
		"Potential null contract violation: insufficient nullness information regarding return value while the method is declared as @NonNull.\n" + 
		"----------\n");
}
// a non-null method returns a non-null return of another method, mixed use of fully qualified name / explicit import
public void test_nonnull_return_007() {
	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");
	customOptions.put(CompilerOptions.OPTION_DefaultImportNullAnnotationTypes, CompilerOptions.DISABLED);
	runConformTest(
		new String[] {
			"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"
		},
		"",
		null/*classLibs*/,
		true/*shouldFlushOutputDirectory*/,
		null/*vmArguments*/,
		customOptions,
		null/*compilerRequestor*/);
}
// a non-null method returns a non-null return of another method, use of explicit imports throughout
public void test_nonnull_return_008() {
	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");
	customOptions.put(CompilerOptions.OPTION_DefaultImportNullAnnotationTypes, CompilerOptions.DISABLED);
	runConformTest(
		new String[] {
			"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(@NonNull Lib l) {\n" +
			"        Object o = l.getObject();" +
			"        return o;\n" +
			"    }\n" +
			"}\n"
		},
		"",
		null/*classLibs*/,
		true/*shouldFlushOutputDirectory*/,
		null/*vmArguments*/,
		customOptions,
		null/*compilerRequestor*/);
}
// a non-null method returns a non-null return of another method, default import plus explicit ones
public void test_nonnull_return_009() {
	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");
	customOptions.put(CompilerOptions.OPTION_DefaultImportNullAnnotationTypes, CompilerOptions.ENABLED);
	runConformTest(
		new String[] {
			"libpack/Lib.java",
			"package libpack;\n" +
			"public class Lib {\n" +
			"    public @NonNull Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"import libpack.Lib;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(@NonNull Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n"
		},
		"",
		null/*classLibs*/,
		true/*shouldFlushOutputDirectory*/,
		null/*vmArguments*/,
		customOptions,
		null/*compilerRequestor*/);
}
// a non-null method returns a non-null return of another method, default import but unspecified annotation names
public void test_nonnull_return_010() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NullableAnnotationName, null);
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, null);
	customOptions.put(CompilerOptions.OPTION_DefaultImportNullAnnotationTypes, CompilerOptions.ENABLED);
	runConformTest(
		new String[] {
			"libpack/Lib.java",
			"package libpack;\n" +
			"public class Lib {\n" +
			"    public @NonNull Object getObject() { return new Object(); }\n" +
			"}\n",
			"X.java",
			"import libpack.Lib;\n" +
			"public class X {\n" +
			"    @NonNull Object getObject(@NonNull Lib l) {\n" +
			"        return l.getObject();\n" +
			"    }\n" +
			"}\n"
		},
		"",
		null/*classLibs*/,
		true/*shouldFlushOutputDirectory*/,
		null/*vmArguments*/,
		customOptions,
		null/*compilerRequestor*/);
}
// a non-null method returns a non-null return of another method, emulation names conflict with existing types
public void test_nonnull_return_011() {
	Map customOptions = getCompilerOptions();
	customOptions.put(CompilerOptions.OPTION_ReportNullReference, CompilerOptions.ERROR);
	customOptions.put(CompilerOptions.OPTION_NullableAnnotationName, "libpack.Lib");
	customOptions.put(CompilerOptions.OPTION_NonNullAnnotationName, "libpack.Lib");
	customOptions.put(CompilerOptions.OPTION_DefaultImportNullAnnotationTypes, CompilerOptions.ENABLED);
	runNegativeTest(
		true/*shouldFlushOutputDirectory*/,
		new String[] {
			"libpack/Lib.java",
			"package libpack;\n" +
			"public class Lib {\n" +
			"}\n",
		},
		null/*classLibs*/,
		customOptions,
		"----------\n" + 
		"1. ERROR in libpack\\Lib.java (at line 0)\n" + 
		"	package libpack;\n" + 
		"	^\n" + 
		"Buildpath problem: emulation of type libpack.Lib is requested (for null annotations) but a type of this name exists on the build path.\n" + 
		"----------\n",
		JavacTestOptions.SKIP);
}
// a method tries to relax the null contract, super declares @NonNull return
public void test_nonnull_return_012() {
	runConformTest(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		});
	runNegativeTest(
		false /* flush output directory */,
		new String[] {
			"X.java",
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    @Nullable Object getObject() { return null; }\n" +
			"}\n"
		},
		// compiler options
		null /* no class libraries */,
		null /* no custom options */,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	@Nullable Object getObject() { return null; }\n" + 
		"	                 ^^^^^^^^^^^\n" + 
		"Cannot relax null contract for method return, inherited method from Lib is declared as @NonNull.\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}
// a method body violates the inherited null contract, super declares @NonNull return
public void test_nonnull_return_013() {
	runConformTest(
		new String[] {
			"Lib.java",
			"public class Lib {\n" +
			"    @NonNull Object getObject() { return new Object(); }\n" +
			"}\n"
		});
	runNegativeTest(
		false /* flush output directory */,
		new String[] {
			"X.java",
			"public class X extends Lib {\n" +
			"    @Override\n" +
			"    Object getObject() { return null; }\n" +
			"}\n"
		},
		// compiler options
		null /* no class libraries */,
		null /* no custom options */,
		"----------\n" + 
		"1. ERROR in X.java (at line 3)\n" + 
		"	Object getObject() { return null; }\n" + 
		"	                     ^^^^^^^^^^^^\n" + 
		"Null contract violation: returning null from a method declared as @NonNull.\n" + 
		"----------\n",
		JavacTestOptions.Excuse.EclipseWarningConfiguredAsError);
}

}

Return to bug 186342

Lines 12-17 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/Main.java (+22 lines)
12	* Benjamin Muskalla - Contribution for bug 239066	12	* Benjamin Muskalla - Contribution for bug 239066
13	* Stephan Herrmann - Contribution for bug 236385	13	* Stephan Herrmann - Contribution for bug 236385
14	* Stephan Herrmann - Contribution for bug 295551	14	* Stephan Herrmann - Contribution for bug 295551
		15	* Stephan Herrmann - Contribution for bug 186342
15	*******************************************************************************/	16	*******************************************************************************/
16	package org.eclipse.jdt.internal.compiler.batch;	17	package org.eclipse.jdt.internal.compiler.batch;
17		18
Lines 2388-2393 Link Here
2388	mode = INSIDE_WARNINGS_PROPERTIES;	2389	mode = INSIDE_WARNINGS_PROPERTIES;
2389	continue;	2390	continue;
2390	}	2391	}
		2392	if (currentArg.startsWith("-nullAnnotations:")) { //$NON-NLS-1$
		2393	StringTokenizer tokenizer =
		2394	new StringTokenizer(currentArg.substring("-nullAnnotations:".length()), ","); //$NON-NLS-1$ //$NON-NLS-2$
		2395	while (tokenizer.hasMoreTokens()) {
		2396	String token = tokenizer.nextToken();
		2397	if (token.startsWith("nullable=")) { //$NON-NLS-1$
		2398	this.options.put(CompilerOptions.OPTION_NullableAnnotationName, token.substring("nullable=".length())); //$NON-NLS-1$
		2399	} else if (token.startsWith("nonnull=")) { //$NON-NLS-1$
		2400	this.options.put(CompilerOptions.OPTION_NonNullAnnotationName, token.substring("nonnull=".length())); //$NON-NLS-1$
		2401	} else if (token.equals("emulate")) { //$NON-NLS-1$
		2402	this.options.put(CompilerOptions.OPTION_EmulateNullAnnotationTypes, CompilerOptions.ENABLED);
		2403	} else if (token.equals("import")) { //$NON-NLS-1$
		2404	this.options.put(CompilerOptions.OPTION_DefaultImportNullAnnotationTypes, CompilerOptions.ENABLED);
		2405	} else {
		2406	throw new IllegalArgumentException(
		2407	this.bind("configure.unrecognized.nullannotation.option", token)); //$NON-NLS-1$
		2408	}
		2409	}
		2410	mode = DEFAULT;
		2411	continue;
		2412	}
2391	break;	2413	break;
2392	case INSIDE_TARGET :	2414	case INSIDE_TARGET :
2393	if (this.didSpecifyTarget) {	2415	if (this.didSpecifyTarget) {

Lines 9-14 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/CompilerInvocationTests.java (+19 lines)
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Benjamin Muskalla - Contribution for bug 239066	10	* Benjamin Muskalla - Contribution for bug 239066
11	* Stephan Herrmann - Contribution for bug 236385	11	* Stephan Herrmann - Contribution for bug 236385
		12	* Stephan Herrmann - Contribution for Bug 186342 - [compiler][null]Using annotations for null checking
12	*******************************************************************************/	13	*******************************************************************************/
13	package org.eclipse.jdt.core.tests.compiler.regression;	14	package org.eclipse.jdt.core.tests.compiler.regression;
14		15
Lines 386-394 Link Here
386	expectedProblemAttributes.put("CodeSnippetMissingMethod", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	387	expectedProblemAttributes.put("CodeSnippetMissingMethod", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
387	expectedProblemAttributes.put("ComparingIdentical", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	388	expectedProblemAttributes.put("ComparingIdentical", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
388	expectedProblemAttributes.put("ConflictingImport", new ProblemAttributes(CategorizedProblem.CAT_IMPORT));	389	expectedProblemAttributes.put("ConflictingImport", new ProblemAttributes(CategorizedProblem.CAT_IMPORT));
		390	expectedProblemAttributes.put("ConflictingTypeEmulation", new ProblemAttributes(CategorizedProblem.CAT_BUILDPATH));
389	expectedProblemAttributes.put("ConstructorVarargsArgumentNeedCast", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	391	expectedProblemAttributes.put("ConstructorVarargsArgumentNeedCast", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
390	expectedProblemAttributes.put("CorruptedSignature", new ProblemAttributes(CategorizedProblem.CAT_BUILDPATH));	392	expectedProblemAttributes.put("CorruptedSignature", new ProblemAttributes(CategorizedProblem.CAT_BUILDPATH));
391	expectedProblemAttributes.put("DeadCode", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	393	expectedProblemAttributes.put("DeadCode", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		394	expectedProblemAttributes.put("DefiniteNullFromNonNullMethod", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		395	expectedProblemAttributes.put("DefiniteNullToNonnullParameter", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
392	expectedProblemAttributes.put("DirectInvocationOfAbstractMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	396	expectedProblemAttributes.put("DirectInvocationOfAbstractMethod", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
393	expectedProblemAttributes.put("DisallowedTargetForAnnotation", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	397	expectedProblemAttributes.put("DisallowedTargetForAnnotation", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
394	expectedProblemAttributes.put("DiscouragedReference", new ProblemAttributes(CategorizedProblem.CAT_RESTRICTION));	398	expectedProblemAttributes.put("DiscouragedReference", new ProblemAttributes(CategorizedProblem.CAT_RESTRICTION));
Lines 491-496 Link Here
491	expectedProblemAttributes.put("IllegalPrimitiveOrArrayTypeForEnclosingInstance", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	495	expectedProblemAttributes.put("IllegalPrimitiveOrArrayTypeForEnclosingInstance", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
492	expectedProblemAttributes.put("IllegalQualifiedEnumConstantLabel", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));	496	expectedProblemAttributes.put("IllegalQualifiedEnumConstantLabel", new ProblemAttributes(CategorizedProblem.CAT_MEMBER));
493	expectedProblemAttributes.put("IllegalQualifiedParameterizedTypeAllocation", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	497	expectedProblemAttributes.put("IllegalQualifiedParameterizedTypeAllocation", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
		498	expectedProblemAttributes.put("IllegalRedefinitionToNullableReturn", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		499	expectedProblemAttributes.put("IllegalRedefinitionToNonNullParameter", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
494	expectedProblemAttributes.put("IllegalStaticModifierForMemberType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	500	expectedProblemAttributes.put("IllegalStaticModifierForMemberType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
495	expectedProblemAttributes.put("IllegalTypeVariableSuperReference", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	501	expectedProblemAttributes.put("IllegalTypeVariableSuperReference", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));
496	expectedProblemAttributes.put("IllegalUsageOfQualifiedTypeReference", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));	502	expectedProblemAttributes.put("IllegalUsageOfQualifiedTypeReference", new ProblemAttributes(CategorizedProblem.CAT_SYNTAX));
Lines 697-702 Link Here
697	expectedProblemAttributes.put("NonGenericMethod", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	703	expectedProblemAttributes.put("NonGenericMethod", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
698	expectedProblemAttributes.put("NonGenericType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));	704	expectedProblemAttributes.put("NonGenericType", new ProblemAttributes(CategorizedProblem.CAT_TYPE));
699	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));	705	expectedProblemAttributes.put("NonNullLocalVariableComparisonYieldsFalse", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		706	expectedProblemAttributes.put("NonNullReturnInsufficientInfo", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
		707	expectedProblemAttributes.put("NonNullParameterInsufficientInfo", new ProblemAttributes(CategorizedProblem.CAT_POTENTIAL_PROGRAMMING_PROBLEM));
700	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	708	expectedProblemAttributes.put("NonStaticAccessToStaticField", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
701	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));	709	expectedProblemAttributes.put("NonStaticAccessToStaticMethod", new ProblemAttributes(CategorizedProblem.CAT_CODE_STYLE));
702	expectedProblemAttributes.put("NonStaticContextForEnumMemberType", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));	710	expectedProblemAttributes.put("NonStaticContextForEnumMemberType", new ProblemAttributes(CategorizedProblem.CAT_INTERNAL));