Attachment #86247 for bug #186342

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

and this patch

Line 1 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-2 / +1 lines)
1	#Thu Nov 01 22:46:18 EDT 2007	1	#Fri Jan 04 23:22:13 CET 2008
2	--

Line 1 Link Here

(-).settings/org.eclipse.jdt.ui.prefs (-2 / +2 lines)
1	#Mon Mar 05 01:19:14 CET 2007	1	#Fri Jan 04 23:22:13 CET 2008
2	--
Line 50 Link Here
		50	org.eclipse.jdt.ui.text.custom_code_templates=<?xml version\="1.0" encoding\="UTF-8"?><templates/>

Line 1309 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (+7 lines)
	1309
	1310	int LocalCannotBeAssignedPotentiallyNull = Internal + 903;
	1311	int CannotPassPotentiallyNullExpressionAsArgument = Internal + 904;
	1312	int CannotReturnPotentiallyNullExpression = Internal + 905;
	1313	int NonNullAnnotationIsMissingForOverridingMethod = Internal + 906;
	1314	int NonNullAnnotationIsMissingForArgumentInOverridingMethod = Internal + 907;
	1315




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

import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;

/** 
 * Return <code>true</code> if <code>ab</code> contains
 * a non-null annotation.
 */
public static boolean isNonNullAnnotated(Scope currentScope, AnnotationBinding[] ab) {
	if (ab == null || ab.length == 0)
		return false;
	if (currentScope.compilerOptions().getSeverity(CompilerOptions.NullReference) != ProblemSeverities.Ignore) {
		// TODO: use lazy creation
		char[][] annotations = CharOperation.splitOn(';', currentScope.compilerOptions().nonNullAnnotations.toCharArray());
		for (int i = 0; i < ab.length; i++) {
			if (ab[i] != null) {
				for (int j = 0; j < annotations.length; j++) {
					char[] annotation = ab[i].getAnnotationType().readableName();
					if (CharOperation.compareTo(annotation, annotations[j]) == 0) {
						return true;
					}
				}
			}
		}
	}
	return false;
}


Line 25 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Assignment.java (-6 / +23 lines)
25		25	private boolean isNonNull;
26	--	26
Line 34 Link Here
		35	this.isNonNull = false;
Line 36 Link Here
		38
Line 47 Link Here
		50	if (isNonNull && nullStatus != FlowInfo.NON_NULL)
		51	local.declaringScope.problemReporter().localCannotBeAssignedWithPotentiallyNull(local, expression);
Line 60 Link Here
60	flowInfo.markAsDefinitelyUnknown(local);	65	if (isNonNull)
61	--	66	flowInfo.markAsDefinitelyNonNull(local);
		67	else
		68	flowInfo.markAsDefinitelyUnknown(local);
Line 71 Link Here
71	flowContext.initsOnFinally.markAsDefinitelyUnknown(local);	79	if (isNonNull)
72	--	80	flowContext.initsOnFinally.markAsDefinitelyNonNull(local);
		81	else
		82	flowContext.initsOnFinally.markAsDefinitelyUnknown(local);
Line 156 Link Here
		167	if (isNonNull)
		168	return FlowInfo.NON_NULL;
Line 202 Link Here
		215	// check for NonNull annotation
		216	LocalVariableBinding local = this.lhs.localVariableBinding();
		217	if (local != null && local.kind() == Binding.LOCAL
		218	&& (local.type.tagBits & TagBits.IsBaseType) == 0) {
		219	isNonNull = isNonNullAnnotated(scope, local.getAnnotations());
		220	}
		221




		// TODO: if allowed, simpler check would be for left and right nullStatus equality (for != UNKNOW)
		Expression tmp = left;
		while (tmp instanceof CastExpression)
			tmp = ((CastExpression)tmp).expression;
		if (tmp instanceof MessageSend) {
			MessageSend ms = (MessageSend)tmp;
			int rightNullStatus = right.nullStatus(flowInfo);
			if ((rightNullStatus == FlowInfo.NULL
					|| rightNullStatus == FlowInfo.NON_NULL)
					&& isNonNullAnnotated(scope, ms.binding.getAnnotations()))
				scope.problemReporter().cannotReturnPotentiallyNullExpression(left);
		}

		tmp = right;
		while (tmp instanceof CastExpression)
			tmp = ((CastExpression)tmp).expression;
		if (tmp instanceof MessageSend) {
			MessageSend ms = (MessageSend)tmp;
			int rightNullStatus = left.nullStatus(flowInfo);
			if ((rightNullStatus == FlowInfo.NULL
					|| rightNullStatus == FlowInfo.NON_NULL)
					&& isNonNullAnnotated(scope, ms.binding.getAnnotations()))
				scope.problemReporter().cannotReturnPotentiallyNullExpression(right);
		}

Line 65 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LocalDeclaration.java (+2 lines)
	65	if (isNonNullAnnotated(currentScope, binding.getAnnotations()) && nullStatus != FlowInfo.NON_NULL)
	66	binding.declaringScope.problemReporter().localCannotBeAssignedWithPotentiallyNull(binding, initialization);

Line 23 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-92 / +64 lines)
		23	import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
Line 42 Link Here
42		43
43	--
Line 58 Link Here
58		59
59	--	60	private boolean isReturnValueNonNull = false;
		61
Line 69 Link Here
		72	final AnnotationBinding[][] parameterAnnotations = binding.getParameterAnnotations();
Line 71 Link Here
		75
		76	if (arguments[i].nullStatus(flowInfo) != FlowInfo.NON_NULL
		77	&& isNonNullAnnotated(currentScope, parameterAnnotations[i])) {
		78	currentScope.problemReporter().cannotPassPotentiallyNullExpressionAsArgument(binding, arguments[i]);
		79	}
Line 77 Link Here
77	// TODO (maxime) the copy above is needed because of a side effect into	86	// TODO (maxime) the copy above is needed because of a side effect into
78	--
Line 81 Link Here
81	manageSyntheticAccessIfNecessary(currentScope, flowInfo);	90	manageSyntheticAccessIfNecessary(currentScope, flowInfo);
82	--
Line 95 Link Here
95	if (originalBinding != this.binding	104	if (originalBinding != this.binding
96	--
Line 99 Link Here
99	TypeBinding targetType = (!compileTimeType.isBaseType() && runtimeTimeType.isBaseType())	108	TypeBinding targetType = (!compileTimeType.isBaseType() && runtimeTimeType.isBaseType())
100	--
Line 103 Link Here
103	} else if (this.actualReceiverType.isArrayType()	112	} else if (this.actualReceiverType.isArrayType()
104	--
Lines 105-106 Link Here
105	&& this.binding.parameters == Binding.NO_PARAMETERS	114	&& this.binding.parameters == Binding.NO_PARAMETERS
106	&& scope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_5	115	&& scope.compilerOptions().complianceLevel >= ClassFileConstants.JDK1_5
107	--
Line 109 Link Here
109	this.valueCast = runtimeTimeType;	118	this.valueCast = runtimeTimeType;
110	--
Line 114 Link Here
114	scope.problemReporter().invalidType(this,	123	scope.problemReporter().invalidType(this,
115	--
Line 120 Link Here
120	}	129	}
121	--
Line 131 Link Here
131	*/	140	*/
132	--
Line 143 Link Here
143	ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((this.bits & ASTNode.DepthMASK) >> ASTNode.DepthSHIFT);	152	ReferenceBinding targetType = currentScope.enclosingSourceType().enclosingTypeAt((this.bits & ASTNode.DepthMASK) >> ASTNode.DepthSHIFT);
144	--
Line 148 Link Here
148	if (this.receiverGenericCast != null)	157	if (this.receiverGenericCast != null)
149	--
Line 151 Link Here
151		160
152	--
Line 201 Link Here
201	}	210	}
202	--
Line 203 Link Here
203	public boolean isSuperAccess() {	212	public boolean isSuperAccess() {
204	--
Line 206 Link Here
206	public boolean isTypeAccess() {	215	public boolean isTypeAccess() {
207	--
Line 217 Link Here
217	// depth is set for both implicit and explicit access (see MethodBinding#canBeSeenBy)	226	// depth is set for both implicit and explicit access (see MethodBinding#canBeSeenBy)
218	--
Line 219 Link Here
219		228
220	--
Lines 236-237 Link Here
236	if (((this.bits & ASTNode.DepthMASK) != 0)	245	if (((this.bits & ASTNode.DepthMASK) != 0)
237	&& this.codegenBinding.declaringClass.getPackage()	246	&& this.codegenBinding.declaringClass.getPackage()
238	--
Line 246 Link Here
246		255
247	--
Line 250 Link Here
250	// and not from Object or implicit static method call.	259	// and not from Object or implicit static method call.
251	--
Line 263 Link Here
263	// Post 1.4.0 target, array clone() invocations are qualified with array type	272	// Post 1.4.0 target, array clone() invocations are qualified with array type
264	--
Line 268 Link Here
		277	if (isReturnValueNonNull)
		278	return FlowInfo.NON_NULL;
Line 276 Link Here
276	if (this.valueCast != null)	287	if (this.valueCast != null)
277	--
Line 305 Link Here
305	}	316	}
306	--
Line 311 Link Here
311		322
312	--
Line 313 Link Here
313		324
314	--
Line 327 Link Here
327	for (int i = 0; i < this.arguments.length ; i ++) {	338	for (int i = 0; i < this.arguments.length ; i ++) {
328	--
Line 340 Link Here
340	boolean receiverCast = false, argsContainCast = false;	351	boolean receiverCast = false, argsContainCast = false;
341	--
Line 345 Link Here
345	this.actualReceiverType = this.receiver.resolveType(scope);	356	this.actualReceiverType = this.receiver.resolveType(scope);
346	--
Lines 349-350 Link Here
349	if (((CastExpression)this.receiver).expression.resolvedType == this.actualReceiverType) {	360	if (((CastExpression)this.receiver).expression.resolvedType == this.actualReceiverType) {
350	scope.problemReporter().unnecessaryCast((CastExpression)this.receiver);	361	scope.problemReporter().unnecessaryCast((CastExpression)this.receiver);
351	--
Line 370 Link Here
370	}	381	}
371	--
Line 374 Link Here
374	boolean argHasError = false; // typeChecks all arguments	385	boolean argHasError = false; // typeChecks all arguments
375	--
Line 393 Link Here
393	this.binding =	404	this.binding =
394	--
Line 425 Link Here
425	this.binding =	436	this.binding =
426	--
Line 428 Link Here
428	: scope.getMethod(this.actualReceiverType, this.selector, argumentTypes, this);	439	: scope.getMethod(this.actualReceiverType, this.selector, argumentTypes, this);
429	--
Line 433 Link Here
433	} else {	444	} else {
434	--
Line 455 Link Here
455	MethodBinding closestMatchOriginal = closestMatch.original();	466	MethodBinding closestMatchOriginal = closestMatch.original();
456	--
Lines 468-469 Link Here
468	if (this.actualReceiverType.isRawType()	479	if (this.actualReceiverType.isRawType()
469	&& (this.receiver.bits & ASTNode.IgnoreRawTypeCheck) == 0	480	&& (this.receiver.bits & ASTNode.IgnoreRawTypeCheck) == 0
470	--
Line 490 Link Here
490	}	501	}
491	--
Lines 505-507 Link Here
505	if (this.actualReceiverType.isArrayType()	516	if (this.actualReceiverType.isArrayType()
506	&& this.binding.parameters == Binding.NO_PARAMETERS	517	&& this.binding.parameters == Binding.NO_PARAMETERS
507	&& compilerOptions.complianceLevel >= ClassFileConstants.JDK1_5	518	&& compilerOptions.complianceLevel >= ClassFileConstants.JDK1_5
508	--
Line 530 Link Here
		541
		542	if (isNonNullAnnotated(scope, binding.getAnnotations()))
		543	isReturnValueNonNull = true;
		544
Line 560 Link Here
560	}	575	}
561	--

Line 21 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MethodDeclaration.java (-32 / +125 lines)
		21	import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
Line 23 Link Here
		24	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
		25	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
Line 31 Link Here
31		34
32	--
Line 34 Link Here
34		37
35	--
Lines 53-55 Link Here
53		56
54	if (!this.binding.isUsed() &&	57	if (!this.binding.isUsed() &&
55	(this.binding.isPrivate()	58	(this.binding.isPrivate()
56	--
Line 61 Link Here
61		64
62	--
Line 69 Link Here
69		72
70	--	73	boolean[] argumentIsNonNull = null;
		74	if (arguments != null)
		75	argumentIsNonNull = new boolean[arguments.length];
		76
		77	ReferenceBinding declaringClassRef = binding.declaringClass;
		78
		79	if ((returnType.bits & TagBits.IsBaseType) == 0) {
		80
		81	ReferenceBinding type = isOverriddenMethodNonNullAnnotated(declaringClassRef, -1, classScope);
		82	if (type != null && !isNonNullAnnotated(classScope, binding.getAnnotations()))
		83	classScope.problemReporter().nonNullAnnotationIsMissingForOverridingMethod(type, binding, this);
		84	}
		85
		86	final AnnotationBinding[][] parameterAnnotations = binding.getParameterAnnotations();
		87	if (arguments != null) {
		88	for (int i = 0; i < arguments.length; i++) {
		89	ReferenceBinding type = isOverriddenMethodNonNullAnnotated(declaringClassRef, i, classScope);
		90	boolean argIsNonNull = isNonNullAnnotated(classScope, parameterAnnotations[i]);
		91	if (type != null && !argIsNonNull)
		92	classScope.problemReporter().nonNullAnnotationIsMissingForArgumentInOverridingMethod(type, binding, arguments[i]);
		93
		94	argumentIsNonNull[i] = type != null \|\| argIsNonNull;
		95	}
		96	}
		97
		98	if (argumentIsNonNull != null) {
		99	for (int i = 0; i < argumentIsNonNull.length; i++) {
		100	if (!argumentIsNonNull[i] && isNonNullAnnotated(classScope, parameterAnnotations[i]))
		101	argumentIsNonNull[i] = true;
		102	}
		103	}
		104
Line 82 Link Here
		117	if (argumentIsNonNull[i])
		118	flowInfo.markAsDefinitelyNonNull(this.arguments[i].binding);
Line 103 Link Here
103	if (flowInfo != FlowInfo.DEAD_END) {	140	if (flowInfo != FlowInfo.DEAD_END) {
104	--
Line 116 Link Here
		153
		154	/**
		155	* Check all the overridden methods (super classes and interfaces)
		156	* searching for NonNull annotation. Return the first type which
		157	* contains an annotated overridden method.
		158	*
		159	* @param declaringClassRef the base type
		160	* @param argument if positive, search annotations on parameters, else
		161	* search on method
		162	* @param classScope
		163	* @return the type containing the overridden and annotated method
		164	* or null
		165	*/
		166	public ReferenceBinding isOverriddenMethodNonNullAnnotated(ReferenceBinding declaringClassRef, int argument, ClassScope classScope) {
		167	if (declaringClassRef == null)
		168	return null;
		169
		170	if (binding.isPrivate() \|\| binding.isConstructor())
		171	return null;
		172
		173	ReferenceBinding superClassRef = declaringClassRef.superclass();
		174	if (superClassRef != null) {
		175	MethodBinding mb = superClassRef.getExactMethod(selector, binding.parameters, classScope.compilationUnitScope());
		176
		177	if (mb != null) {
		178	boolean nonNullAnnotated;
		179	if (argument < 0)
		180	nonNullAnnotated = isNonNullAnnotated(classScope, mb.getAnnotations());
		181	else
		182	nonNullAnnotated = isNonNullAnnotated(classScope, mb.getParameterAnnotations()[argument]);
		183
		184	// if an annotation is found, returns
		185	if (nonNullAnnotated)
		186	return superClassRef;
		187	} else {
		188	ReferenceBinding type = isOverriddenMethodNonNullAnnotated(superClassRef, argument, classScope);
		189	if (type != null)
		190	return type;
		191	}
		192	}
		193
		194	// if an overridden method have been found, but it was not annotated
		195	// the check continues through the interfaces
		196
		197	ReferenceBinding[] superInterfacesRef = declaringClassRef.superInterfaces();
		198	if (superInterfacesRef != null) {
		199	for (int i = 0; i < superInterfacesRef.length; i++) {
		200	if (superInterfacesRef[i] != null) {
		201	MethodBinding mb = superInterfacesRef[i].getExactMethod(selector, binding.parameters, classScope.compilationUnitScope());
		202
		203	if (mb != null) {
		204	boolean nonNullAnnotated;
		205	if (argument < 0)
		206	nonNullAnnotated = isNonNullAnnotated(classScope, mb.getAnnotations());
		207	else
		208	nonNullAnnotated = isNonNullAnnotated(classScope, mb.getParameterAnnotations()[argument]);
		209
		210	if (nonNullAnnotated)
		211	return superInterfacesRef[i];
		212	} else {
		213	ReferenceBinding type = isOverriddenMethodNonNullAnnotated(superInterfacesRef[i], argument, classScope);
		214	if (type != null)
		215	return type;
		216	}
217	}
218	}
219	}
220
221	return null;
222	}
223
Line 140 Link Here
140		248
141	--
Line 146 Link Here
146		254
147	--
Line 167 Link Here
167	} else if (!isInterfaceMethod	275	} else if (!isInterfaceMethod
168	--
Line 173 Link Here
173		281
174	--
Line 181 Link Here
181	// native methods may have a semicolon body	289	// native methods may have a semicolon body
182	--
Line 187 Link Here
187	// the method HAS a body --> abstract native modifiers are forbiden	295	// the method HAS a body --> abstract native modifiers are forbidden
188	--
Line 193 Link Here
193		301
194	--
Line 224 Link Here
224	}	332	}
225	--
Line 247 Link Here
247	}	355	}
248	--

Line 40 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ReturnStatement.java (+8 lines)
	40
	41	AbstractMethodDeclaration methodDecl = currentScope.methodScope().referenceMethod();
	42	MethodBinding methodBinding = methodDecl.binding;
	43
	44	if ((methodBinding.returnType.tagBits & TagBits.IsBaseType) == 0
	45	&& expression.nullStatus(flowInfo) != FlowInfo.NON_NULL
	46	&& isNonNullAnnotated(currentScope, methodBinding.getAnnotations()))
	47	currentScope.problemReporter().cannotReturnPotentiallyNullExpression(expression);

Line 120 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/CompilerOptions.java (-6 / +12 lines)
		120	public static final String OPTION_Non_Null_Annotations = "org.eclipse.jdt.core.compiler.nonNullAnnotations"; //$NON-NLS-1$
Line 340 Link Here
		341	// annotations list for null checks (separator is ';')
		342	public String nonNullAnnotations = "org.NonNull;edu.umd.cs.findbugs.annotations.NonNull"; //$NON-NLS-1$
		343
Line 458 Link Here
		462	optionsMap.put(OPTION_Non_Null_Annotations, this.nonNullAnnotations);
Line 750 Link Here
750	}	755	}
751	--
Line 937 Link Here
937	}	942	}
938	--
Line 940 Link Here
940	}	945	}
941	--
Line 976 Link Here
		981	if ((optionValue = optionsMap.get(OPTION_Non_Null_Annotations)) != null) {
		982	this.nonNullAnnotations = (String)optionValue;
		983	}
Line 1063 Link Here
		1071	buf.append("\n\t- non null annotations list (';'): ").append(this.nonNullAnnotations); //$NON-NLS-1$

Line 33 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (-963 / +624 lines)
33		33
34	--
Line 49 Link Here
49	case IProblem.MaskedCatch :	49	case IProblem.MaskedCatch :
50	--
Line 54 Link Here
54		54
55	--
Line 57 Link Here
57		57
58	--
Lines 65-66 Link Here
65	case IProblem.OverridingDeprecatedMethod :	65	case IProblem.OverridingDeprecatedMethod :
66	case IProblem.UsingDeprecatedType :	66	case IProblem.UsingDeprecatedType :
67	--
Line 71 Link Here
71		71
72	--
Line 74 Link Here
74		74
75	--
Line 84 Link Here
84	case IProblem.NeedToEmulateConstructorAccess :	84	case IProblem.NeedToEmulateConstructorAccess :
85	--
Line 93 Link Here
93		93
94	--
Line 130 Link Here
130		130
131	--
Line 140 Link Here
140		140
141	--
Line 144 Link Here
144		144
145	--
Line 147 Link Here
147		147
148	--
Line 154 Link Here
154		154
155	--
Line 174 Link Here
174		174
175	--
Line 179 Link Here
179		179
180	--
Line 185 Link Here
185		185
186	--
Line 201 Link Here
201		201
202	--
Line 209 Link Here
209		209
210	--
Line 216 Link Here
216		216
217	--
Line 219 Link Here
219		219
220	--
Line 225 Link Here
225		225
226	--
Line 307 Link Here
307		307
308	--
Line 310 Link Here
310		310
311	--
Line 317 Link Here
		317
		318	case IProblem.LocalCannotBeAssignedPotentiallyNull:
		319	case IProblem.CannotReturnPotentiallyNullExpression:
		320	case IProblem.CannotPassPotentiallyNullExpressionAsArgument:
		321	case IProblem.NonNullAnnotationIsMissingForOverridingMethod:
		322	case IProblem.NonNullAnnotationIsMissingForArgumentInOverridingMethod:
		323	return CompilerOptions.NullReference;
Line 343 Link Here
343		350
344	--
Line 351 Link Here
351		358
352	--
Line 357 Link Here
357		364
358	--
Line 366 Link Here
366		373
367	--
Line 369 Link Here
369		376
370	--
Line 372 Link Here
372		379
373	--
Line 375 Link Here
375		382
376	--
Line 381 Link Here
381		388
382	--
Line 384 Link Here
384		391
385	--
Line 399 Link Here
399		406
400	--
Line 403 Link Here
403	case (int)(CompilerOptions.PotentialNullReference >>> 32):	410	case (int)(CompilerOptions.PotentialNullReference >>> 32):
404	--
Line 409 Link Here
409		416
410	--
Line 412 Link Here
412		419
413	--
Line 422 Link Here
422		429
423	--
Line 429 Link Here
429	}	436	}
430	--
Line 436 Link Here
436		443
437	--
Line 471 Link Here
471	new String(type.sourceName()),	478	new String(type.sourceName()),
472	--
Line 478 Link Here
478	new String(type.sourceName()),	485	new String(type.sourceName()),
479	--
Line 505 Link Here
505	new String[] {	512	new String[] {
506	--
Lines 507-508 Link Here
507	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),	514	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),
508	new String(decl.name),	515	new String(decl.name),
509	--
Line 510 Link Here
510	new String[] {	517	new String[] {
511	--
Lines 512-513 Link Here
512	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),	519	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),
513	new String(decl.name),	520	new String(decl.name),
514	--
Line 522 Link Here
522	new String[] {	529	new String[] {
523	--
Lines 524-526 Link Here
524	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),	531	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),
525	new String(abstractMethod.declaringClass.readableName()),	532	new String(abstractMethod.declaringClass.readableName()),
526	new String(type.readableName()),	533	new String(type.readableName()),
527	--
Line 528 Link Here
528	new String[] {	535	new String[] {
529	--
Lines 530-532 Link Here
530	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),	537	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),
531	new String(abstractMethod.declaringClass.shortReadableName()),	538	new String(abstractMethod.declaringClass.shortReadableName()),
532	new String(type.shortReadableName()),	539	new String(type.shortReadableName()),
533	--
Line 564 Link Here
564	new String(inheritedMethod.selector),	571	new String(inheritedMethod.selector),
565	--
Line 569 Link Here
569	new String(inheritedMethod.selector),	576	new String(inheritedMethod.selector),
570	--
Line 572 Link Here
572	location.sourceEnd);	579	location.sourceEnd);
573	--
Line 736 Link Here
736	String[] arguments = new String[] { new String(name) };	743	String[] arguments = new String[] { new String(name) };
737	--
Line 901 Link Here
901	new String[] {	908	new String[] {
902	--
Line 903 Link Here
903	typesAsString(enumConstructor.isVarargs(), enumConstructor.parameters, false),	910	typesAsString(enumConstructor.isVarargs(), enumConstructor.parameters, false),
904	--
Line 905 Link Here
905	new String[] {	912	new String[] {
906	--
Line 907 Link Here
907	typesAsString(enumConstructor.isVarargs(), enumConstructor.parameters, true),	914	typesAsString(enumConstructor.isVarargs(), enumConstructor.parameters, true),
908	--
Line 986 Link Here
986	nodeSourceEnd(field, location));	993	nodeSourceEnd(field, location));
987	--
Line 1061 Link Here
1061		1068
1062	--
Line 1102 Link Here
1102	return ProblemSeverities.Ignore;	1109	return ProblemSeverities.Ignore;
1103	--
Line 1125 Link Here
1125	return ProblemSeverities.Ignore;	1132	return ProblemSeverities.Ignore;
1126	--
Line 1144 Link Here
1144	if ((problemID & IProblem.Javadoc) != 0 && !this.options.docCommentSupport)	1151	if ((problemID & IProblem.Javadoc) != 0 && !this.options.docCommentSupport)
1145	--
Line 1169 Link Here
1169	// this code is called on IntLiteral and LongLiteral	1176	// this code is called on IntLiteral and LongLiteral
1170	--
Line 1206 Link Here
1206		1213
1207	--
Line 1365 Link Here
1365	typesAsString(inheritedMethod1.isVarargs(), inheritedMethod1.original().parameters, false),	1372	typesAsString(inheritedMethod1.isVarargs(), inheritedMethod1.original().parameters, false),
1366	--
Line 1370 Link Here
1370	typesAsString(inheritedMethod1.isVarargs(), inheritedMethod1.original().parameters, true),	1377	typesAsString(inheritedMethod1.isVarargs(), inheritedMethod1.original().parameters, true),
1371	--
Line 1469 Link Here
1469	? IProblem.DuplicateModifierForArgument	1476	? IProblem.DuplicateModifierForArgument
1470	--
Line 1505 Link Here
1505	nodeSourceEnd(field, reference));	1512	nodeSourceEnd(field, reference));
1506	--
Line 1532 Link Here
1532	sourceEnd);	1539	sourceEnd);
1533	--
Line 1540 Link Here
1540	new String[] {	1547	new String[] {
1541	--
Lines 1542-1543 Link Here
1542	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),	1549	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),
1543	new String(abstractMethod.declaringClass.readableName()),	1550	new String(abstractMethod.declaringClass.readableName()),
1544	--
Line 1545 Link Here
1545	new String[] {	1552	new String[] {
1546	--
Lines 1547-1548 Link Here
1547	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),	1554	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),
1548	new String(abstractMethod.declaringClass.shortReadableName()),	1555	new String(abstractMethod.declaringClass.shortReadableName()),
1549	--
Line 1557 Link Here
1557	new String[] {	1564	new String[] {
1558	--
Lines 1559-1560 Link Here
1559	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),	1566	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, false),
1560	new String(field.name),	1567	new String(field.name),
1561	--
Line 1562 Link Here
1562	new String[] {	1569	new String[] {
1563	--
Lines 1564-1565 Link Here
1564	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),	1571	typesAsString(abstractMethod.isVarargs(), abstractMethod.parameters, true),
1565	new String(field.name),	1572	new String(field.name),
1566	--
Line 1592 Link Here
1592	nodeSourceEnd(field, reference));	1599	nodeSourceEnd(field, reference));
1593	--
Line 1705 Link Here
1705	/** @param classpathEntryType one of {@link AccessRestriction#COMMAND_LINE},	1712	/** @param classpathEntryType one of {@link AccessRestriction#COMMAND_LINE},
1706	--
Line 1707 Link Here
1707	public void forbiddenReference(FieldBinding field, ASTNode location,	1714	public void forbiddenReference(FieldBinding field, ASTNode location,
1708	--
Lines 1715-1716 Link Here
1715	new String[] {	1722	new String[] {
1716	classpathEntryName,	1723	classpathEntryName,
1717	--
Line 1723 Link Here
1723	/** @param classpathEntryType one of {@link AccessRestriction#COMMAND_LINE},	1730	/** @param classpathEntryType one of {@link AccessRestriction#COMMAND_LINE},
1724	--
Line 1725 Link Here
1725	public void forbiddenReference(MethodBinding method, ASTNode location,	1732	public void forbiddenReference(MethodBinding method, ASTNode location,
1726	--
Line 1728 Link Here
1728	if (severity == ProblemSeverities.Ignore) return;	1735	if (severity == ProblemSeverities.Ignore) return;
1729	--
Lines 1734-1735 Link Here
1734	new String[] {	1741	new String[] {
1735	classpathEntryName,	1742	classpathEntryName,
1736	--
Lines 1745-1746 Link Here
1745	new String[] {	1752	new String[] {
1746	classpathEntryName,	1753	classpathEntryName,
1747	--
Line 1753 Link Here
1753	/** @param classpathEntryType one of {@link AccessRestriction#COMMAND_LINE},	1760	/** @param classpathEntryType one of {@link AccessRestriction#COMMAND_LINE},
1754	--
Line 1755 Link Here
1755	public void forbiddenReference(TypeBinding type, ASTNode location,	1762	public void forbiddenReference(TypeBinding type, ASTNode location,
1756	--
Line 1765 Link Here
1765	classpathEntryName,	1772	classpathEntryName,
1766	--
Line 1800 Link Here
1800	int problemId,	1807	int problemId,
1801	--
Line 1803 Link Here
1803	int problemStartPosition,	1810	int problemStartPosition,
1804	--
Lines 1812-1813 Link Here
1812	this.referenceContext,	1819	this.referenceContext,
1813	this.referenceContext == null ? null : this.referenceContext.compilationResult());	1820	this.referenceContext == null ? null : this.referenceContext.compilationResult());
1814	--
Line 1817 Link Here
1817	// reference context.	1824	// reference context.
1818	--
Line 1819 Link Here
1819	int problemId,	1826	int problemId,
1820	--
Line 1822 Link Here
1822	int problemStartPosition,	1829	int problemStartPosition,
1823	--
Lines 1832-1833 Link Here
1832	this.referenceContext,	1839	this.referenceContext,
1833	unitResult);	1840	unitResult);
1834	--
Line 1840 Link Here
1840	int problemId,	1847	int problemId,
1841	--
Line 1844 Link Here
1844	int problemStartPosition,	1851	int problemStartPosition,
1845	--
Line 1854 Link Here
1854	problemEndPosition);	1861	problemEndPosition);
1855	--
Line 1860 Link Here
1860	int problemId,	1867	int problemId,
1861	--
Line 1865 Link Here
1865	int problemStartPosition,	1872	int problemStartPosition,
1866	--
Lines 1875-1876 Link Here
1875	this.referenceContext,	1882	this.referenceContext,
1876	this.referenceContext == null ? null : this.referenceContext.compilationResult());	1883	this.referenceContext == null ? null : this.referenceContext.compilationResult());
1877	--
Line 1885 Link Here
1885	},	1892	},
1886	--
Line 1888 Link Here
1888	},	1895	},
1889	--
Line 1946 Link Here
1946	arguments,	1953	arguments,
1947	--
Line 1956 Link Here
1956	arguments,	1963	arguments,
1957	--
Lines 1964-1965 Link Here
1964	NoArgument,	1971	NoArgument,
1965	NoArgument,	1972	NoArgument,
1966	--
Lines 1972-1973 Link Here
1972	NoArgument,	1979	NoArgument,
1973	NoArgument,	1980	NoArgument,
1974	--
Line 2004 Link Here
2004		2011
2005	--
Line 2009 Link Here
2009	problemID = IProblem.CannotDefineAnnotationInLocalType;	2016	problemID = IProblem.CannotDefineAnnotationInLocalType;
2010	--
Line 2011 Link Here
2011	problemID = IProblem.CannotDefineInterfaceInLocalType;	2018	problemID = IProblem.CannotDefineInterfaceInLocalType;
2012	--
Line 2049 Link Here
2049	},	2056	},
2050	--
Line 2053 Link Here
2053	},	2060	},
2054	--
Line 2063 Link Here
2063	},	2070	},
2064	--
Line 2067 Link Here
2067	},	2074	},
2068	--
Lines 2120-2121 Link Here
2120	NoArgument,	2127	NoArgument,
2121	NoArgument,	2128	NoArgument,
2122	--
Line 2151 Link Here
2151	},	2158	},
2152	--
Line 2155 Link Here
2155	},	2162	},
2156	--
Line 2166 Link Here
2166	},	2173	},
2167	--
Line 2171 Link Here
2171	},	2178	},
2172	--
Line 2227 Link Here
2227	},	2234	},
2228	--
Line 2232 Link Here
2232	},	2239	},
2233	--
Line 2261 Link Here
2261	qualifiedTypeReference.sourceEnd);	2268	qualifiedTypeReference.sourceEnd);
2262	--
Line 2285 Link Here
2285	qualifiedTypeReference.sourceEnd);	2292	qualifiedTypeReference.sourceEnd);
2286	--
Lines 2378-2381 Link Here
2378	IProblem.ImportNotFound,	2385	IProblem.ImportNotFound,
2379	arguments,	2386	arguments,
2380	arguments,	2387	arguments,
2381	importRef.sourceStart,	2388	importRef.sourceStart,
2382	--
Lines 2389-2392 Link Here
2389	IProblem.InvalidTypeForStaticImport,	2396	IProblem.InvalidTypeForStaticImport,
2390	arguments,	2397	arguments,
2391	arguments,	2398	arguments,
2392	importRef.sourceStart,	2399	importRef.sourceStart,
2393	--
Line 2401 Link Here
2401	if (currentMethod.declaringClass.isInterface()	2408	if (currentMethod.declaringClass.isInterface()
2402	--
Line 2427 Link Here
2427	} else	2434	} else
2428	--
Line 2474 Link Here
2474	if (declaringClass.isInterface()	2481	if (declaringClass.isInterface()
2475	--
Line 2659 Link Here
2659	},	2666	},
2660	--
Line 2666 Link Here
2666	},	2673	},
2667	--
Line 2721 Link Here
2721		2728
2722	--
Line 2730 Link Here
2730	}	2737	}
2731	--
Line 2732 Link Here
2732	boolean insideDefaultConstructor =	2739	boolean insideDefaultConstructor =
2733	--
Line 2748 Link Here
2748		2755
2749	--
Line 2772 Link Here
2772	}	2779	}
2773	--
Line 2794 Link Here
2794	new String[] {	2801	new String[] {
2795	--
Lines 2796-2800 Link Here
2796	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	2803	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
2797	new String(shownConstructor.declaringClass.readableName()),	2804	new String(shownConstructor.declaringClass.readableName()),
2798	typesAsString(false, invocationArguments, false),	2805	typesAsString(false, invocationArguments, false),
2799	new String(inferredTypeArgument.readableName()),	2806	new String(inferredTypeArgument.readableName()),
2800	new String(typeParameter.sourceName),	2807	new String(typeParameter.sourceName),
2801	--
Line 2802 Link Here
2802	new String[] {	2809	new String[] {
2803	--
Lines 2804-2808 Link Here
2804	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	2811	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
2805	new String(shownConstructor.declaringClass.shortReadableName()),	2812	new String(shownConstructor.declaringClass.shortReadableName()),
2806	typesAsString(false, invocationArguments, true),	2813	typesAsString(false, invocationArguments, true),
2807	new String(inferredTypeArgument.shortReadableName()),	2814	new String(inferredTypeArgument.shortReadableName()),
2808	new String(typeParameter.sourceName),	2815	new String(typeParameter.sourceName),
2809	--
Lines 2811-2813 Link Here
2811	sourceEnd);	2818	sourceEnd);
2812	return;	2819	return;
2813		2820
2814	--
Line 2820 Link Here
2820	new String[] {	2827	new String[] {
2821	--
Lines 2822-2823 Link Here
2822	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	2829	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
2823	new String(shownConstructor.declaringClass.readableName()),	2830	new String(shownConstructor.declaringClass.readableName()),
2824	--
Line 2825 Link Here
2825	new String[] {	2832	new String[] {
2826	--
Lines 2827-2828 Link Here
2827	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	2834	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
2828	new String(shownConstructor.declaringClass.shortReadableName()),	2835	new String(shownConstructor.declaringClass.shortReadableName()),
2829	--
Line 2831 Link Here
2831	sourceEnd);	2838	sourceEnd);
2832	--
Line 2835 Link Here
2835	new String[] {	2842	new String[] {
2836	--
Lines 2837-2838 Link Here
2837	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	2844	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
2838	new String(shownConstructor.declaringClass.readableName()),	2845	new String(shownConstructor.declaringClass.readableName()),
2839	--
Line 2841 Link Here
2841	new String[] {	2848	new String[] {
2842	--
Lines 2843-2844 Link Here
2843	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	2850	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
2844	new String(shownConstructor.declaringClass.shortReadableName()),	2851	new String(shownConstructor.declaringClass.shortReadableName()),
2845	--
Line 2848 Link Here
2848	sourceEnd);	2855	sourceEnd);
2849	--
Line 2856 Link Here
2856	new String[] {	2863	new String[] {
2857	--
Lines 2858-2859 Link Here
2858	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	2865	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
2859	new String(shownConstructor.declaringClass.readableName()),	2866	new String(shownConstructor.declaringClass.readableName()),
2860	--
Line 2862 Link Here
2862	new String[] {	2869	new String[] {
2863	--
Lines 2864-2865 Link Here
2864	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	2871	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
2865	new String(shownConstructor.declaringClass.shortReadableName()),	2872	new String(shownConstructor.declaringClass.shortReadableName()),
2866	--
Line 2869 Link Here
2869	sourceEnd);	2876	sourceEnd);
2870	--
Line 2876 Link Here
2876	new String[] {	2883	new String[] {
2877	--
Lines 2878-2879 Link Here
2878	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	2885	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
2879	new String(shownConstructor.declaringClass.readableName()),	2886	new String(shownConstructor.declaringClass.readableName()),
2880	--
Line 2881 Link Here
2881	new String[] {	2888	new String[] {
2882	--
Lines 2883-2884 Link Here
2883	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	2890	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
2884	new String(shownConstructor.declaringClass.shortReadableName()),	2891	new String(shownConstructor.declaringClass.shortReadableName()),
2885	--
Line 2887 Link Here
2887	sourceEnd);	2894	sourceEnd);
2888	--
Line 2914 Link Here
2914		2921
2915	--
Line 2943 Link Here
2943		2950
2944	--
Line 2961 Link Here
2961		2968
2962	--
Line 3000 Link Here
3000		3007
3001	--
Line 3079 Link Here
3079		3086
3080	--
Line 3081 Link Here
3081		3088
3082	--
Line 3113 Link Here
3113	nodeSourceStart(field, nameRef),	3120	nodeSourceStart(field, nameRef),
3114	--
Line 3143 Link Here
3143	id,	3150	id,
3144	--
Line 3146 Link Here
3146	nameRef.sourceStart,	3153	nameRef.sourceStart,
3147	--
Line 3155 Link Here
3155	annotation.sourceEnd);	3162	annotation.sourceEnd);
3156	--
Line 3160 Link Here
3160		3167
3161	--
Line 3179 Link Here
3179	parameterTypeNames	3186	parameterTypeNames
3180	--
Line 3190 Link Here
3190	}	3197	}
3191	--
Line 3197 Link Here
3197	}	3204	}
3198	--
Line 3230 Link Here
3230	new String[] {	3237	new String[] {
3231	--
Lines 3232-3236 Link Here
3232	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	3239	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
3233	new String(shownMethod.declaringClass.readableName()),	3240	new String(shownMethod.declaringClass.readableName()),
3234	typesAsString(false, invocationArguments, false),	3241	typesAsString(false, invocationArguments, false),
3235	new String(inferredTypeArgument.readableName()),	3242	new String(inferredTypeArgument.readableName()),
3236	new String(typeParameter.sourceName),	3243	new String(typeParameter.sourceName),
3237	--
Line 3238 Link Here
3238	new String[] {	3245	new String[] {
3239	--
Lines 3240-3244 Link Here
3240	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	3247	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
3241	new String(shownMethod.declaringClass.shortReadableName()),	3248	new String(shownMethod.declaringClass.shortReadableName()),
3242	typesAsString(false, invocationArguments, true),	3249	typesAsString(false, invocationArguments, true),
3243	new String(inferredTypeArgument.shortReadableName()),	3250	new String(inferredTypeArgument.shortReadableName()),
3244	new String(typeParameter.sourceName),	3251	new String(typeParameter.sourceName),
3245	--
Line 3247 Link Here
3247	(int) messageSend.nameSourcePosition);	3254	(int) messageSend.nameSourcePosition);
3248	--
Line 3255 Link Here
3255	new String[] {	3262	new String[] {
3256	--
Lines 3257-3258 Link Here
3257	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	3264	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
3258	new String(shownMethod.declaringClass.readableName()),	3265	new String(shownMethod.declaringClass.readableName()),
3259	--
Line 3260 Link Here
3260	new String[] {	3267	new String[] {
3261	--
Lines 3262-3263 Link Here
3262	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	3269	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
3263	new String(shownMethod.declaringClass.shortReadableName()),	3270	new String(shownMethod.declaringClass.shortReadableName()),
3264	--
Line 3266 Link Here
3266	(int) messageSend.nameSourcePosition);	3273	(int) messageSend.nameSourcePosition);
3267	--
Line 3270 Link Here
3270	new String[] {	3277	new String[] {
3271	--
Lines 3272-3273 Link Here
3272	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	3279	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
3273	new String(shownMethod.declaringClass.readableName()),	3280	new String(shownMethod.declaringClass.readableName()),
3274	--
Line 3276 Link Here
3276	new String[] {	3283	new String[] {
3277	--
Lines 3278-3279 Link Here
3278	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	3285	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
3279	new String(shownMethod.declaringClass.shortReadableName()),	3286	new String(shownMethod.declaringClass.shortReadableName()),
3280	--
Line 3283 Link Here
3283	(int) messageSend.nameSourcePosition);	3290	(int) messageSend.nameSourcePosition);
3284	--
Line 3291 Link Here
3291	new String[] {	3298	new String[] {
3292	--
Lines 3293-3294 Link Here
3293	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	3300	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
3294	new String(shownMethod.declaringClass.readableName()),	3301	new String(shownMethod.declaringClass.readableName()),
3295	--
Line 3297 Link Here
3297	new String[] {	3304	new String[] {
3298	--
Lines 3299-3300 Link Here
3299	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	3306	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
3300	new String(shownMethod.declaringClass.shortReadableName()),	3307	new String(shownMethod.declaringClass.shortReadableName()),
3301	--
Line 3304 Link Here
3304	(int) messageSend.nameSourcePosition);	3311	(int) messageSend.nameSourcePosition);
3305	--
Line 3311 Link Here
3311	new String[] {	3318	new String[] {
3312	--
Lines 3313-3314 Link Here
3313	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	3320	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
3314	new String(shownMethod.declaringClass.readableName()),	3321	new String(shownMethod.declaringClass.readableName()),
3315	--
Line 3316 Link Here
3316	new String[] {	3323	new String[] {
3317	--
Lines 3318-3319 Link Here
3318	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	3325	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
3319	new String(shownMethod.declaringClass.shortReadableName()),	3326	new String(shownMethod.declaringClass.shortReadableName()),
3320	--
Line 3322 Link Here
3322	(int) messageSend.nameSourcePosition);	3329	(int) messageSend.nameSourcePosition);
3323	--
Line 3424 Link Here
3424		3431
3425	--
Line 3445 Link Here
3445	case ProblemReasons.IllegalSuperTypeVariable :	3452	case ProblemReasons.IllegalSuperTypeVariable :
3446	--
Line 3453 Link Here
3453		3460
3454	--
Line 3495 Link Here
3495	new String[] {new String(type.leafComponentType().readableName()) },	3502	new String[] {new String(type.leafComponentType().readableName()) },
3496	--
Line 3543 Link Here
3543	NoArgument,	3550	NoArgument,
3544	--
Line 3546 Link Here
3546	annotation.sourceEnd);	3553	annotation.sourceEnd);
3547	--
Lines 3551-3552 Link Here
3551	NoArgument,	3558	NoArgument,
3552	NoArgument,	3559	NoArgument,
3553	--
Lines 3559-3560 Link Here
3559	NoArgument,	3566	NoArgument,
3560	NoArgument,	3567	NoArgument,
3561	--
Lines 3567-3568 Link Here
3567	NoArgument,	3574	NoArgument,
3568	NoArgument,	3575	NoArgument,
3569	--
Lines 3575-3576 Link Here
3575	NoArgument,	3582	NoArgument,
3576	NoArgument,	3583	NoArgument,
3577	--
Lines 3583-3584 Link Here
3583	NoArgument,	3590	NoArgument,
3584	NoArgument,	3591	NoArgument,
3585	--
Lines 3591-3592 Link Here
3591	NoArgument,	3598	NoArgument,
3592	NoArgument,	3599	NoArgument,
3593	--
Lines 3601-3602 Link Here
3601	NoArgument,	3608	NoArgument,
3602	NoArgument,	3609	NoArgument,
3603	--
Lines 3611-3612 Link Here
3611	NoArgument,	3618	NoArgument,
3612	NoArgument,	3619	NoArgument,
3613	--
Lines 3619-3620 Link Here
3619	NoArgument,	3626	NoArgument,
3620	NoArgument,	3627	NoArgument,
3621	--
Lines 3627-3628 Link Here
3627	NoArgument,	3634	NoArgument,
3628	NoArgument,	3635	NoArgument,
3629	--
Line 3649 Link Here
3649	arguments,	3656	arguments,
3650	--
Line 3710 Link Here
3710	default:	3717	default:
3711	--
Line 3723 Link Here
3723	default:	3730	default:
3724	--
Line 3732 Link Here
3732		3739
3733	--
Line 3736 Link Here
3736		3743
3737	--
Line 3924 Link Here
3924		3931
3925	--
Line 3930 Link Here
3930		3937
3931	--
Line 3933 Link Here
3933	new String[] {	3940	new String[] {
3934	--
Lines 3935-3939 Link Here
3935	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	3942	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
3936	new String(shownConstructor.declaringClass.readableName()),	3943	new String(shownConstructor.declaringClass.readableName()),
3937	typesAsString(false, invocationArguments, false),	3944	typesAsString(false, invocationArguments, false),
3938	new String(inferredTypeArgument.readableName()),	3945	new String(inferredTypeArgument.readableName()),
3939	new String(typeParameter.sourceName),	3946	new String(typeParameter.sourceName),
3940	--
Line 3941 Link Here
3941	new String[] {	3948	new String[] {
3942	--
Lines 3943-3947 Link Here
3943	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	3950	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
3944	new String(shownConstructor.declaringClass.shortReadableName()),	3951	new String(shownConstructor.declaringClass.shortReadableName()),
3945	typesAsString(false, invocationArguments, true),	3952	typesAsString(false, invocationArguments, true),
3946	new String(inferredTypeArgument.shortReadableName()),	3953	new String(inferredTypeArgument.shortReadableName()),
3947	new String(typeParameter.sourceName),	3954	new String(typeParameter.sourceName),
3948	--
Lines 3951-3953 Link Here
3951	sourceEnd);	3958	sourceEnd);
3952	return;	3959	return;
3953		3960
3954	--
Line 3963 Link Here
3963	new String[] {	3970	new String[] {
3964	--
Lines 3965-3966 Link Here
3965	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	3972	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
3966	new String(shownConstructor.declaringClass.readableName()),	3973	new String(shownConstructor.declaringClass.readableName()),
3967	--
Line 3968 Link Here
3968	new String[] {	3975	new String[] {
3969	--
Lines 3970-3971 Link Here
3970	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	3977	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
3971	new String(shownConstructor.declaringClass.shortReadableName()),	3978	new String(shownConstructor.declaringClass.shortReadableName()),
3972	--
Line 3975 Link Here
3975	sourceEnd);	3982	sourceEnd);
3976	--
Line 3979 Link Here
3979	new String[] {	3986	new String[] {
3980	--
Lines 3981-3982 Link Here
3981	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	3988	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
3982	new String(shownConstructor.declaringClass.readableName()),	3989	new String(shownConstructor.declaringClass.readableName()),
3983	--
Line 3985 Link Here
3985	new String[] {	3992	new String[] {
3986	--
Lines 3987-3988 Link Here
3987	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	3994	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
3988	new String(shownConstructor.declaringClass.shortReadableName()),	3995	new String(shownConstructor.declaringClass.shortReadableName()),
3989	--
Line 3993 Link Here
3993	sourceEnd);	4000	sourceEnd);
3994	--
Line 4003 Link Here
4003	new String[] {	4010	new String[] {
4004	--
Lines 4005-4006 Link Here
4005	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	4012	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
4006	new String(shownConstructor.declaringClass.readableName()),	4013	new String(shownConstructor.declaringClass.readableName()),
4007	--
Line 4009 Link Here
4009	new String[] {	4016	new String[] {
4010	--
Lines 4011-4012 Link Here
4011	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	4018	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
4012	new String(shownConstructor.declaringClass.shortReadableName()),	4019	new String(shownConstructor.declaringClass.shortReadableName()),
4013	--
Line 4017 Link Here
4017	sourceEnd);	4024	sourceEnd);
4018	--
Line 4026 Link Here
4026	new String[] {	4033	new String[] {
4027	--
Lines 4028-4029 Link Here
4028	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),	4035	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, false),
4029	new String(shownConstructor.declaringClass.readableName()),	4036	new String(shownConstructor.declaringClass.readableName()),
4030	--
Line 4031 Link Here
4031	new String[] {	4038	new String[] {
4032	--
Lines 4033-4034 Link Here
4033	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),	4040	typesAsString(shownConstructor.isVarargs(), shownConstructor.parameters, true),
4034	new String(shownConstructor.declaringClass.shortReadableName()),	4041	new String(shownConstructor.declaringClass.shortReadableName()),
4035	--
Line 4038 Link Here
4038	sourceEnd);	4045	sourceEnd);
4039	--
Line 4132 Link Here
4132	parameterTypeNames	4139	parameterTypeNames
4133	--
Line 4166 Link Here
4166	new String[] {	4173	new String[] {
4167	--
Lines 4168-4172 Link Here
4168	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	4175	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
4169	new String(shownMethod.declaringClass.readableName()),	4176	new String(shownMethod.declaringClass.readableName()),
4170	typesAsString(false, invocationArguments, false),	4177	typesAsString(false, invocationArguments, false),
4171	new String(inferredTypeArgument.readableName()),	4178	new String(inferredTypeArgument.readableName()),
4172	new String(typeParameter.sourceName),	4179	new String(typeParameter.sourceName),
4173	--
Line 4174 Link Here
4174	new String[] {	4181	new String[] {
4175	--
Lines 4176-4180 Link Here
4176	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	4183	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
4177	new String(shownMethod.declaringClass.shortReadableName()),	4184	new String(shownMethod.declaringClass.shortReadableName()),
4178	typesAsString(false, invocationArguments, true),	4185	typesAsString(false, invocationArguments, true),
4179	new String(inferredTypeArgument.shortReadableName()),	4186	new String(inferredTypeArgument.shortReadableName()),
4180	new String(typeParameter.sourceName),	4187	new String(typeParameter.sourceName),
4181	--
Line 4184 Link Here
4184	(int) messageSend.nameSourcePosition);	4191	(int) messageSend.nameSourcePosition);
4185	--
Line 4195 Link Here
4195	new String[] {	4202	new String[] {
4196	--
Lines 4197-4198 Link Here
4197	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	4204	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
4198	new String(shownMethod.declaringClass.readableName()),	4205	new String(shownMethod.declaringClass.readableName()),
4199	--
Line 4200 Link Here
4200	new String[] {	4207	new String[] {
4201	--
Lines 4202-4203 Link Here
4202	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	4209	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
4203	new String(shownMethod.declaringClass.shortReadableName()),	4210	new String(shownMethod.declaringClass.shortReadableName()),
4204	--
Line 4207 Link Here
4207	(int) messageSend.nameSourcePosition);	4214	(int) messageSend.nameSourcePosition);
4208	--
Line 4211 Link Here
4211	new String[] {	4218	new String[] {
4212	--
Lines 4213-4214 Link Here
4213	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	4220	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
4214	new String(shownMethod.declaringClass.readableName()),	4221	new String(shownMethod.declaringClass.readableName()),
4215	--
Line 4217 Link Here
4217	new String[] {	4224	new String[] {
4218	--
Lines 4219-4220 Link Here
4219	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	4226	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
4220	new String(shownMethod.declaringClass.shortReadableName()),	4227	new String(shownMethod.declaringClass.shortReadableName()),
4221	--
Line 4225 Link Here
4225	(int) messageSend.nameSourcePosition);	4232	(int) messageSend.nameSourcePosition);
4226	--
Line 4235 Link Here
4235	new String[] {	4242	new String[] {
4236	--
Lines 4237-4238 Link Here
4237	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	4244	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
4238	new String(shownMethod.declaringClass.readableName()),	4245	new String(shownMethod.declaringClass.readableName()),
4239	--
Line 4241 Link Here
4241	new String[] {	4248	new String[] {
4242	--
Lines 4243-4244 Link Here
4243	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	4250	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
4244	new String(shownMethod.declaringClass.shortReadableName()),	4251	new String(shownMethod.declaringClass.shortReadableName()),
4245	--
Line 4249 Link Here
4249	(int) messageSend.nameSourcePosition);	4256	(int) messageSend.nameSourcePosition);
4250	--
Line 4258 Link Here
4258	new String[] {	4265	new String[] {
4259	--
Lines 4260-4261 Link Here
4260	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),	4267	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, false),
4261	new String(shownMethod.declaringClass.readableName()),	4268	new String(shownMethod.declaringClass.readableName()),
4262	--
Line 4263 Link Here
4263	new String[] {	4270	new String[] {
4264	--
Lines 4265-4266 Link Here
4265	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),	4272	typesAsString(shownMethod.isVarargs(), shownMethod.parameters, true),
4266	new String(shownMethod.declaringClass.shortReadableName()),	4273	new String(shownMethod.declaringClass.shortReadableName()),
4267	--
Line 4270 Link Here
4270	(int) messageSend.nameSourcePosition);	4277	(int) messageSend.nameSourcePosition);
4271	--
Line 4301 Link Here
4301	/**	4308	/**
4302	--
Line 4311 Link Here
4311	/**	4318	/**
4312	--
Lines 4556-4557 Link Here
4556	int id = (local instanceof Argument)	4563	int id = (local instanceof Argument)
4557	? IProblem.ArgumentHidingLocalVariable	4564	? IProblem.ArgumentHidingLocalVariable
4558	--
Line 4600 Link Here
		4607	public void localCannotBeAssignedWithPotentiallyNull(LocalVariableBinding local, ASTNode location) {
		4608	int severity = computeSeverity(IProblem.LocalCannotBeAssignedPotentiallyNull);
		4609	if (severity == ProblemSeverities.Ignore) return;
		4610	String[] arguments = new String[] { new String(local.name) };
		4611	this.handle(
		4612	IProblem.LocalCannotBeAssignedPotentiallyNull,
		4613	arguments,
		4614	arguments,
		4615	severity,
		4616	nodeSourceStart(local, location),
		4617	nodeSourceEnd(local, location));
		4618	}
		4619	public void cannotReturnPotentiallyNullExpression(ASTNode location) {
		4620	int severity = computeSeverity(IProblem.CannotReturnPotentiallyNullExpression);
		4621	if (severity == ProblemSeverities.Ignore) return;
		4622	String[] arguments = new String[] { };
		4623	this.handle(
		4624	IProblem.CannotReturnPotentiallyNullExpression,
		4625	arguments,
		4626	arguments,
		4627	severity,
		4628	location.sourceStart,
		4629	location.sourceEnd);
		4630	}
		4631	public void nonNullAnnotationIsMissingForOverridingMethod(ReferenceBinding type, MethodBinding method, ASTNode location) {
		4632	int severity = computeSeverity(IProblem.NonNullAnnotationIsMissingForOverridingMethod);
		4633	if (severity == ProblemSeverities.Ignore) return;
		4634	String[] arguments = new String[] { new String(type.readableName()), new String(method.readableName()) };
		4635	this.handle(
		4636	IProblem.NonNullAnnotationIsMissingForOverridingMethod,
		4637	arguments,
		4638	arguments,
		4639	severity,
		4640	location.sourceStart,
		4641	location.sourceEnd);
		4642	}
		4643	public void nonNullAnnotationIsMissingForArgumentInOverridingMethod(ReferenceBinding type, MethodBinding method, Argument arg) {
		4644	int severity = computeSeverity(IProblem.NonNullAnnotationIsMissingForArgumentInOverridingMethod);
		4645	if (severity == ProblemSeverities.Ignore) return;
		4646	String[] arguments = new String[] { new String(type.readableName()), new String(method.readableName()), new String(arg.name) };
		4647	this.handle(
		4648	IProblem.NonNullAnnotationIsMissingForArgumentInOverridingMethod,
		4649	arguments,
		4650	arguments,
		4651	severity,
		4652	arg.sourceStart,
		4653	arg.sourceEnd);
		4654	}
		4655	public void cannotPassPotentiallyNullExpressionAsArgument(MethodBinding method, ASTNode location) {
		4656	int severity = computeSeverity(IProblem.CannotPassPotentiallyNullExpressionAsArgument);
		4657	if (severity == ProblemSeverities.Ignore) return;
		4658	String[] arguments = new String[] { new String(method.readableName()) };
		4659	this.handle(
		4660	IProblem.CannotPassPotentiallyNullExpressionAsArgument,
		4661	arguments,
		4662	arguments,
		4663	severity,
		4664	nodeSourceStart(method, location),
		4665	nodeSourceEnd(method, location));
		4666	}
Line 4702 Link Here
4702	},	4769	},
4703	--
Line 4709 Link Here
4709	},	4776	},
4710	--
Line 4728 Link Here
4728	}	4795	}
4729	--
Line 4844 Link Here
4844	compUnitDecl.sourceStart + 1);	4911	compUnitDecl.sourceStart + 1);
4845	--
Line 4864 Link Here
4864	this.abortDueToInternalError(Messages.abort_missingCode, location);	4931	this.abortDueToInternalError(Messages.abort_missingCode, location);
4865	--
Line 4868 Link Here
4868	int id = isReadAccess	4935	int id = isReadAccess
4869	--
Line 4882 Link Here
4882	MethodBinding method,	4949	MethodBinding method,
4883	--
Line 4891 Link Here
4891	IProblem.NeedToEmulateConstructorAccess,	4958	IProblem.NeedToEmulateConstructorAccess,
4892	--
Line 4893 Link Here
4893	new String(method.declaringClass.readableName()),	4960	new String(method.declaringClass.readableName()),
4894	--
Line 4895 Link Here
4895	},	4962	},
4896	--
Line 4897 Link Here
4897	new String(method.declaringClass.shortReadableName()),	4964	new String(method.declaringClass.shortReadableName()),
4898	--
Line 4899 Link Here
4899	},	4966	},
4900	--
Lines 4901-4902 Link Here
4901	location.sourceStart,	4968	location.sourceStart,
4902	location.sourceEnd);	4969	location.sourceEnd);
4903	--
Line 4908 Link Here
4908	IProblem.NeedToEmulateMethodAccess,	4975	IProblem.NeedToEmulateMethodAccess,
4909	--
Lines 4910-4911 Link Here
4910	new String(method.declaringClass.readableName()),	4977	new String(method.declaringClass.readableName()),
4911	new String(method.selector),	4978	new String(method.selector),
4912	--
Line 4913 Link Here
4913	},	4980	},
4914	--
Lines 4915-4916 Link Here
4915	new String(method.declaringClass.shortReadableName()),	4982	new String(method.declaringClass.shortReadableName()),
4916	new String(method.selector),	4983	new String(method.selector),
4917	--
Line 4918 Link Here
4918	},	4985	},
4919	--
Lines 4920-4921 Link Here
4920	location.sourceStart,	4987	location.sourceStart,
4921	location.sourceEnd);	4988	location.sourceEnd);
4922	--
Line 5126 Link Here
5126	} else if (location instanceof AllocationExpression	5193	} else if (location instanceof AllocationExpression
5127	--
Line 5128 Link Here
5128	\|\| (((AllocationExpression) location).binding.declaringClass.isAnonymousType()	5195	\|\| (((AllocationExpression) location).binding.declaringClass.isAnonymousType()
5129	--
Line 5139 Link Here
5139	new String[] { new String(targetType.readableName())},	5206	new String[] { new String(targetType.readableName())},
5140	--
Lines 5358-5359 Link Here
5358	int startPosition,	5425	int startPosition,
5359	int endPosition,	5426	int endPosition,
5360	--
Lines 5361-5362 Link Here
5361	char[] currentTokenSource,	5428	char[] currentTokenSource,
5362	String errorTokenName,	5429	String errorTokenName,
5363	--
Line 5364 Link Here
5364		5431
5365	--
Line 5410 Link Here
5410	//extract the literal when it's a literal	5477	//extract the literal when it's a literal
5411	--
Lines 5433-5434 Link Here
5433	start,	5500	start,
5434	end,	5501	end,
5435	--
Line 5436 Link Here
5436	errorTokenSource,	5503	errorTokenSource,
5437	--
Line 5438 Link Here
5438	null);	5505	null);
5439	--
Lines 5460-5461 Link Here
5460	start,	5527	start,
5461	end,	5528	end,
5462	--
Lines 5463-5465 Link Here
5463	errorTokenSource,	5530	errorTokenSource,
5464	errorTokenName,	5531	errorTokenName,
5465	expectedToken);	5532	expectedToken);
5466	--
Lines 5476-5477 Link Here
5476	start,	5543	start,
5477	end,	5544	end,
5478	--
Lines 5479-5481 Link Here
5479	errorTokenSource,	5546	errorTokenSource,
5480	errorTokenName,	5547	errorTokenName,
5481	expectedToken);	5548	expectedToken);
5482	--
Lines 5530-5531 Link Here
5530	start,	5597	start,
5531	end,	5598	end,
5532	--
Lines 5533-5535 Link Here
5533	errorTokenSource,	5600	errorTokenSource,
5534	errorTokenName,	5601	errorTokenName,
5535	expectedToken);	5602	expectedToken);
5536	--
Lines 5567-5568 Link Here
5567	start,	5634	start,
5568	end,	5635	end,
5569	--
Line 5570 Link Here
5570	errorTokenSource,	5637	errorTokenSource,
5571	--
Line 5572 Link Here
5572	null);	5639	null);
5573	--
Lines 5593-5594 Link Here
5593	start,	5660	start,
5594	end,	5661	end,
5595	--
Lines 5596-5598 Link Here
5596	errorTokenSource,	5663	errorTokenSource,
5597	errorTokenName,	5664	errorTokenName,
5598	expectedToken);	5665	expectedToken);
5599	--
Line 5615 Link Here
5615		5682
5616	--
Line 5618 Link Here
5618	arguments = new String[] {Messages.parser_endOfConstructor};	5685	arguments = new String[] {Messages.parser_endOfConstructor};
5619	--
Line 5620 Link Here
5620	arguments = new String[] {Messages.parser_endOfMethod};	5687	arguments = new String[] {Messages.parser_endOfMethod};
5621	--
Line 5622 Link Here
5622	arguments = new String[] {Messages.parser_endOfInitializer};	5689	arguments = new String[] {Messages.parser_endOfInitializer};
5623	--
Line 5624 Link Here
5624	arguments = new String[] {Messages.parser_endOfFile};	5691	arguments = new String[] {Messages.parser_endOfFile};
5625	--
Line 5692 Link Here
5692	new String(constructorCall.binding.declaringClass.readableName()),	5759	new String(constructorCall.binding.declaringClass.readableName()),
5693	--
Line 5696 Link Here
5696	new String(constructorCall.binding.declaringClass.shortReadableName()),	5763	new String(constructorCall.binding.declaringClass.shortReadableName()),
5697	--
Line 5908 Link Here
5908	String[] arguments = flag == IProblem.ParsingErrorNoSuggestion	5975	String[] arguments = flag == IProblem.ParsingErrorNoSuggestion
5909	--
Line 5912 Link Here
5912	flag,	5979	flag,
5913	--
Line 5916 Link Here
5916	startPos,	5983	startPos,
5917	--
Line 5964 Link Here
5964	nodeSourceEnd(field, location));	6031	nodeSourceEnd(field, location));
5965	--
Line 6026 Link Here
6026	sourceEnd);	6093	sourceEnd);
6027	--
Lines 6058-6059 Link Here
6058	int startPosition,	6125	int startPosition,
6059	int endPosition,	6126	int endPosition,
6060	--
Lines 6061-6062 Link Here
6061	char[] currentTokenSource,	6128	char[] currentTokenSource,
6062	String errorTokenName,	6129	String errorTokenName,
6063	--
Line 6091 Link Here
6091	new String[] { tag, message, priority/secret argument that is not surfaced in getMessage()/},	6158	new String[] { tag, message, priority/secret argument that is not surfaced in getMessage()/},
6092	--
Lines 6176-6177 Link Here
6176	new String[] {	6243	new String[] {
6177	new String(typeDecl.name),	6244	new String(typeDecl.name),
6178	--
Line 6181 Link Here
6181	new String(declaringMethod.declaringClass.readableName()),	6248	new String(declaringMethod.declaringClass.readableName()),
6182	--
Line 6183 Link Here
6183	new String[] {	6250	new String[] {
6184	--
Line 6188 Link Here
6188	new String(declaringMethod.declaringClass.shortReadableName()),	6255	new String(declaringMethod.declaringClass.shortReadableName()),
6189	--
Line 6200 Link Here
6200	new String[] { new String(typeDecl.name) , new String(hiddenType.shortReadableName()) },	6267	new String[] { new String(typeDecl.name) , new String(hiddenType.shortReadableName()) },
6201	--
Line 6281 Link Here
6281	new String[] {new String(variableName), new String(binaryType.readableName()) },	6348	new String[] {new String(variableName), new String(binaryType.readableName()) },
6282	--
Line 6315 Link Here
6315	boolean insideDefaultConstructor =	6382	boolean insideDefaultConstructor =
6316	--
Line 6325 Link Here
6325	: (insideImplicitConstructorCall	6392	: (insideImplicitConstructorCall
6326	--
Line 6371 Link Here
6371	IProblem.UnmatchedBracket,	6438	IProblem.UnmatchedBracket,
6372	--
Line 6374 Link Here
6374	position,	6441	position,
6375	--
Line 6435 Link Here
6435	new String[] {	6502	new String[] {
6436	--
Lines 6437-6438 Link Here
6437	typesAsString(method.isVarargs(), method.parameters, false),	6504	typesAsString(method.isVarargs(), method.parameters, false),
6438	new String(method.declaringClass.readableName()),	6505	new String(method.declaringClass.readableName()),
6439	--
Line 6440 Link Here
6440	new String[] {	6507	new String[] {
6441	--
Lines 6442-6443 Link Here
6442	typesAsString(method.isVarargs(), method.parameters, true),	6509	typesAsString(method.isVarargs(), method.parameters, true),
6443	new String(method.declaringClass.shortReadableName()),	6510	new String(method.declaringClass.shortReadableName()),
6444	--
Line 6446 Link Here
6446	typeArguments[typeArguments.length-1].sourceEnd);	6513	typeArguments[typeArguments.length-1].sourceEnd);
6447	--
Line 6476 Link Here
6476	},	6543	},
6477	--
Line 6479 Link Here
6479	},	6546	},
6480	--
Lines 6534-6535 Link Here
6534	new String[]{	6601	new String[]{
6535	new String(castedExpressionType.readableName()),	6602	new String(castedExpressionType.readableName()),
6536	--
Lines 6538-6539 Link Here
6538	new String[]{	6605	new String[]{
6539	new String(castedExpressionType.shortReadableName()),	6606	new String(castedExpressionType.shortReadableName()),
6540	--
Line 6562 Link Here
6562	new String[] {	6629	new String[] {
6563	--
Line 6564 Link Here
6564	new String[] {	6631	new String[] {
6565	--
Line 6568 Link Here
6568	nodeSourceEnd(field, location));	6635	nodeSourceEnd(field, location));
6569	--
Line 6582 Link Here
6582	},	6649	},
6583	--
Line 6591 Link Here
6591	location.sourceEnd);	6658	location.sourceEnd);
6592	--
Line 6600 Link Here
6600	},	6667	},
6601	--
Line 6609 Link Here
6609	location.sourceEnd);	6676	location.sourceEnd);
6610	--
Line 6623 Link Here
6623	},	6690	},
6624	--
Line 6628 Link Here
6628	},	6695	},
6629	--
Line 6631 Link Here
6631	location.sourceEnd);	6698	location.sourceEnd);
6632	--
Line 6640 Link Here
6640	},	6707	},
6641	--
Line 6649 Link Here
6649	location.sourceEnd);	6716	location.sourceEnd);
6650	--
Line 6672 Link Here
6672	},	6739	},
6673	--
Line 6681 Link Here
6681	},	6748	},
6682	--
Line 6695 Link Here
6695	expression.sourceEnd);	6762	expression.sourceEnd);
6696	--
Line 6720 Link Here
6720	},	6787	},
6721	--
Line 6725 Link Here
6725	},	6792	},
6726	--
Line 6737 Link Here
6737	},	6804	},
6738	--
Line 6743 Link Here
6743	},	6810	},
6744	--
Line 6759 Link Here
6759	importRef.sourceEnd);	6826	importRef.sourceEnd);
6760	--
Line 6786 Link Here
6786		6853
6787	--
Line 6789 Link Here
6789		6856
6790	--
Line 6796 Link Here
6796	},	6863	},
6797	--
Line 6800 Link Here
6800	},	6867	},
6801	--
Line 6806 Link Here
6806		6873
6807	--
Line 6811 Link Here
6811		6878
6812	--
Line 6830 Link Here
6830	},	6897	},
6831	--
Line 6834 Link Here
6834	},	6901	},
6835	--
Line 6843 Link Here
6843		6910
6844	--
Line 6845 Link Here
6845		6912
6846	--
Line 6884 Link Here
6884	},	6951	},
6885	--
Line 6889 Link Here
6889	},	6956	},
6890	--
Line 6903 Link Here
6903	},	6970	},
6904	--
Line 6906 Link Here
6906	},	6973	},
6907	--
Line 6917 Link Here
6917	sourceEnd);	6984	sourceEnd);
6918	--
Line 6925 Link Here
6925	sourceEnd);	6992	sourceEnd);
6926	--
Lines 6935-6939 Link Here
6935	new String(argumentType.readableName()),	7002	new String(argumentType.readableName()),
6936	new String(varargsType.readableName()),	7003	new String(varargsType.readableName()),
6937	new String(method.declaringClass.readableName()),	7004	new String(method.declaringClass.readableName()),
6938	typesAsString(method.isVarargs(), method.parameters, false),	7005	typesAsString(method.isVarargs(), method.parameters, false),
6939	new String(varargsType.elementsType().readableName()),	7006	new String(varargsType.elementsType().readableName()),
6940	--
Lines 6942-6946 Link Here
6942	new String(argumentType.shortReadableName()),	7009	new String(argumentType.shortReadableName()),
6943	new String(varargsType.shortReadableName()),	7010	new String(varargsType.shortReadableName()),
6944	new String(method.declaringClass.shortReadableName()),	7011	new String(method.declaringClass.shortReadableName()),
6945	typesAsString(method.isVarargs(), method.parameters, true),	7012	typesAsString(method.isVarargs(), method.parameters, true),
6946	new String(varargsType.elementsType().shortReadableName()),	7013	new String(varargsType.elementsType().shortReadableName()),
6947	--
Lines 6954-6960 Link Here
6954	new String[] {	7021	new String[] {
6955	new String(argumentType.readableName()),	7022	new String(argumentType.readableName()),
6956	new String(varargsType.readableName()),	7023	new String(varargsType.readableName()),
6957	new String(method.selector),	7024	new String(method.selector),
6958	typesAsString(method.isVarargs(), method.parameters, false),	7025	typesAsString(method.isVarargs(), method.parameters, false),
6959	new String(method.declaringClass.readableName()),	7026	new String(method.declaringClass.readableName()),
6960	new String(varargsType.elementsType().readableName()),	7027	new String(varargsType.elementsType().readableName()),
6961	--
Lines 6962-6967 Link Here
6962	new String[] {	7029	new String[] {
6963	new String(argumentType.shortReadableName()),	7030	new String(argumentType.shortReadableName()),
6964	new String(varargsType.shortReadableName()),	7031	new String(varargsType.shortReadableName()),
6965	new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true),	7032	new String(method.selector), typesAsString(method.isVarargs(), method.parameters, true),
6966	new String(method.declaringClass.shortReadableName()),	7033	new String(method.declaringClass.shortReadableName()),
6967	new String(varargsType.elementsType().shortReadableName()),	7034	new String(varargsType.elementsType().shortReadableName()),
6968	--
Line 6977 Link Here
6977	new String[] {	7044	new String[] {
6978	--
Line 6984 Link Here
6984	new String[] {	7051	new String[] {
6985	--
Line 7025 Link Here
7025	new String[] {	7092	new String[] {
7026	--
Line 7027 Link Here
7027	new String[] {	7094	new String[] {
7028	--
Line 7030 Link Here
7030	location.sourceEnd);	7097	location.sourceEnd);
7031	--
Line 7043 Link Here
7043		7110
7044	--
Line 7054 Link Here
7054	},	7121	},
7055	--
Line 7062 Link Here
7062	},	7129	},
7063	--
Line 7064 Link Here
7064	location.sourceEnd);	7131	location.sourceEnd);
7065	--
Line 7075 Link Here
7075	},	7142	},
7076	--
Line 7083 Link Here
7083	},	7150	},
7084	--
Line 7085 Link Here
7085	location.sourceEnd);	7152	location.sourceEnd);
7086	--
Line 7098 Link Here
7098	},	7165	},
7099	--
Line 7102 Link Here
7102	},	7169	},
7103	--

Line 69 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (-18 / +16 lines)
69	79 = Unqualified access to the field {0}.{1}	69	79 = Unqualified access to the field {0}.{1}
70	--
Line 101 Link Here
101	119 = The static method {1}({2}) from the type {0} should be accessed directly	101	119 = The static method {1}({2}) from the type {0} should be accessed directly
102	--
Line 126 Link Here
126	154 = The literal {1} of type {0} is out of range	126	154 = The literal {1} of type {0} is out of range
127	--
Line 167 Link Here
167	196 = The field {0} is defined in an inherited type and an enclosing scope	167	196 = The field {0} is defined in an inherited type and an enclosing scope
168	--
Line 330 Link Here
330		330
331	--
Line 350 Link Here
350	421 = Code snippet support cannot find the method {0}.{1}({2})	350	421 = Code snippet support cannot find the method {0}.{1}({2})
351	--
Line 424 Link Here
424	509 = The field {0} is defined in an inherited type and an enclosing scope	424	509 = The field {0} is defined in an inherited type and an enclosing scope
425	--
Line 429 Link Here
429	514 = Javadoc:	429	514 = Javadoc:
430	--
Line 540 Link Here
540	625 = The value for annotation attribute {0}.{1} must be some @{2} annotation	540	625 = The value for annotation attribute {0}.{1} must be some @{2} annotation
541	--
Line 600 Link Here
		600	### @NonNull annotation
		601	903 = Cannot assign null or potentially null expression to {0} because of @NonNull annotation
		602	904 = Cannot pass null or potentially null expression as argument for method {0} because of @NonNull annotation
		603	905 = Cannot return null or potentially null expression because of @NonNull annotation
		604	906 = Method {1} isn't NonNull annotated while overridden method in {0} is
		605	907 = Argument {2} in method {1} isn't NonNull annotated while overridden method in type {0} is
		606

Return to bug 186342

Line 18 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (+26 lines)
	18	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
Line 19 Link Here
	20	import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
Line 723 Link Here
	725	/**
	726	* Return <code>true</code> if <code>ab</code> contains
	727	* a non-null annotation.
	728	*/
	729	public static boolean isNonNullAnnotated(Scope currentScope, AnnotationBinding[] ab) {
	730	if (ab == null \|\| ab.length == 0)
	731	return false;
	732	if (currentScope.compilerOptions().getSeverity(CompilerOptions.NullReference) != ProblemSeverities.Ignore) {
	733	// TODO: use lazy creation
	734	char[][] annotations = CharOperation.splitOn(';', currentScope.compilerOptions().nonNullAnnotations.toCharArray());
	735	for (int i = 0; i < ab.length; i++) {
	736	if (ab[i] != null) {
	737	for (int j = 0; j < annotations.length; j++) {
	738	char[] annotation = ab[i].getAnnotationType().readableName();
	739	if (CharOperation.compareTo(annotation, annotations[j]) == 0) {
	740	return true;
	741	}
	742	}
	743	}
	744	}
	745	}
	746	return false;
	747	}
	748

Line 31 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/EqualExpression.java (+23 lines)
	31	// TODO: if allowed, simpler check would be for left and right nullStatus equality (for != UNKNOW)
	32	Expression tmp = left;
	33	while (tmp instanceof CastExpression)
	34	tmp = ((CastExpression)tmp).expression;
	35	if (tmp instanceof MessageSend) {
	36	MessageSend ms = (MessageSend)tmp;
	37	int rightNullStatus = right.nullStatus(flowInfo);
	38	if ((rightNullStatus == FlowInfo.NULL
	39	\|\| rightNullStatus == FlowInfo.NON_NULL)
	40	&& isNonNullAnnotated(scope, ms.binding.getAnnotations()))
	41	scope.problemReporter().cannotReturnPotentiallyNullExpression(left);
	42	}
Line 35 Link Here
	47	tmp = right;
	48	while (tmp instanceof CastExpression)
	49	tmp = ((CastExpression)tmp).expression;
	50	if (tmp instanceof MessageSend) {
	51	MessageSend ms = (MessageSend)tmp;
	52	int rightNullStatus = left.nullStatus(flowInfo);
	53	if ((rightNullStatus == FlowInfo.NULL
	54	\|\| rightNullStatus == FlowInfo.NON_NULL)
	55	&& isNonNullAnnotated(scope, ms.binding.getAnnotations()))
	56	scope.problemReporter().cannotReturnPotentiallyNullExpression(right);
	57	}