Attachment #38510 for bug #104293

View | Details | Raw Unified | Return to bug 104293
Collapse All | Expand All




	
	/*
	 * Check unique instance of generic method bindings 
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=104293
	 */
	public void test0214() throws JavaModelException {
    	this.workingCopy = getWorkingCopy("/Converter15/src/X.java", true/*resolve*/);
    	String contents =
			"public class X {\n" + 

		invocation = (MethodInvocation) expression;
		IMethodBinding methodBinding2 = invocation.resolveMethodBinding();
		
		assertTrue("Not identical", methodBinding == methodBinding2);
	}
	
}




import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.RawTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;

			return;
		TypeBinding[] arguments = getTypeBindingArguments();
		if (arguments.length != this.methodBinding.typeVariables().length)
			this.methodBinding = this.environment.createParameterizedGenericMethod(this.methodBinding, (RawTypeBinding) null);
		else
	 		this.methodBinding = this.environment.createParameterizedGenericMethod(this.methodBinding, arguments);
		this.compilerBinding = this.methodBinding;
	}
	

Lines 3886-3892 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-1 / +1 lines)
3886	continue next;	3886	continue next;
3887		3887
3888	if (minTypeArgLength != 0) {	3888	if (minTypeArgLength != 0) {
3889	method = new ParameterizedGenericMethodBinding(method, typeArgTypes, scope.environment());	3889	method = scope.environment().createParameterizedGenericMethod(method, typeArgTypes);
3890	}	3890	}
3891		3891
3892	if (minArgLength > method.parameters.length)	3892	if (minArgLength > method.parameters.length)

Lines 621-627 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java (-2 / +2 lines)
621	fieldBinding.modifiers = modifiers;	621	fieldBinding.modifiers = modifiers;
622	}	622	}
623		623
624	public void checkForErasedCandidateCollisions() {	624	public void checkParameterizedSuperTypeCollisions() {
625	// check for parameterized interface collisions (when different parameterizations occur)	625	// check for parameterized interface collisions (when different parameterizations occur)
626	SourceTypeBinding sourceType = referenceContext.binding;	626	SourceTypeBinding sourceType = referenceContext.binding;
627	ReferenceBinding[] interfaces = sourceType.superInterfaces;	627	ReferenceBinding[] interfaces = sourceType.superInterfaces;
Lines 687-693 Link Here
687	ReferenceBinding[] memberTypes = referenceContext.binding.memberTypes;	687	ReferenceBinding[] memberTypes = referenceContext.binding.memberTypes;
688	if (memberTypes != null && memberTypes != Binding.NO_MEMBER_TYPES)	688	if (memberTypes != null && memberTypes != Binding.NO_MEMBER_TYPES)
689	for (int i = 0, size = memberTypes.length; i < size; i++)	689	for (int i = 0, size = memberTypes.length; i < size; i++)
690	((SourceTypeBinding) memberTypes[i]).scope.checkForErasedCandidateCollisions();	690	((SourceTypeBinding) memberTypes[i]).scope.checkParameterizedSuperTypeCollisions();
691	}	691	}
692		692
693	private void checkForInheritedMemberTypes(SourceTypeBinding sourceType) {	693	private void checkForInheritedMemberTypes(SourceTypeBinding sourceType) {




			        // incompatible due to wrong arity
			        return new ProblemMethodBinding(originalMethod, originalMethod.selector, substitutes, ProblemReasons.TypeParameterArityMismatch);
				}
				methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, substitutes);
				break computeSubstitutes;
			}
			

			return null; // incompatible
		if (substitutes.length == 0) {
			// raw generic method inferred
			return scope.environment().createParameterizedGenericMethod(originalMethod, (RawTypeBinding)null);
		}
		// apply inferred variable substitutions - replacing unresolved variable with original ones in param method
		TypeBinding[] resolvedSubstitutes = substitutes;

				resolvedSubstitutes[i] = substitutes[i];
			}
		}
		return scope.environment().createParameterizedGenericMethod(originalMethod, resolvedSubstitutes);		
	}
	
	private static TypeBinding[] resolveSubstituteConstraints(Scope scope, TypeVariableBinding[] typeVariables, TypeBinding[] substitutes, boolean considerEXTENDSConstraints, Map collectedSubstitutes) {

				TypeBinding[] rawArguments = new TypeBinding[length];
				for (int i = 0; i < length; i++)
					rawArguments[i] =  environment.convertToRawType(originalVariables[i].erasure());
				this.tiebreakMethod = this.environment.createParameterizedGenericMethod(this.originalMethod, rawArguments);
//			}
		} 
		return this.tiebreakMethod;

Lines 304-310 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java (-1 / +1 lines)
304	// must substitute to detect cases like:	304	// must substitute to detect cases like:
305	// <T1 extends X<T1>> void dup() {}	305	// <T1 extends X<T1>> void dup() {}
306	// <T2 extends X<T2>> Object dup() {return null;}	306	// <T2 extends X<T2>> Object dup() {return null;}
307	return new ParameterizedGenericMethodBinding(method, vars, env);	307	return env.createParameterizedGenericMethod(method, vars);
308	}	308	}
309	/*	309	/*
310	* declaringUniqueKey dot selector genericSignature	310	* declaringUniqueKey dot selector genericSignature




		System.arraycopy(resolvedImports, 0, resolvedImports = new ImportBinding[index], 0, index);
	imports = resolvedImports;
}

/**
 * Perform deferred check specific to parameterized types: bound checks, supertype collisions
 */
void checkParameterizedTypes() {
	if (compilerOptions().sourceLevel < ClassFileConstants.JDK1_5) return;

	for (int i = 0, length = topLevelTypes.length; i < length; i++) {
		ClassScope scope = topLevelTypes[i].scope;
		scope.checkParameterizedTypeBounds();
		scope.checkParameterizedSuperTypeCollisions();
	}
}
/*

Lines 445-451 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java (-1 / +1 lines)
445	arguments[i] = inheritedTypeVariables[i].upperBound();	445	arguments[i] = inheritedTypeVariables[i].upperBound();
446	}	446	}
447	ParameterizedGenericMethodBinding substitute =	447	ParameterizedGenericMethodBinding substitute =
448	new ParameterizedGenericMethodBinding(inheritedMethod, arguments, this.environment);	448	this.environment.createParameterizedGenericMethod(inheritedMethod, arguments);
449		449
450	// interface I { <T> void foo(T t); }	450	// interface I { <T> void foo(T t); }
451	// class X implements I { public <T extends I> void foo(T t) {} }	451	// class X implements I { public <T extends I> void foo(T t) {} }




import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;

public class LookupEnvironment implements ProblemReasons, TypeConstants {
	
	final static int BUILD_FIELDS_AND_METHODS = 4;
	final static int BUILD_TYPE_HIERARCHY = 1;
	final static int CHECK_AND_SET_IMPORTS = 2;

	private SimpleLookupTable uniqueParameterizedTypeBindings;
	private SimpleLookupTable uniqueRawTypeBindings;
	private SimpleLookupTable uniqueWildcardBindings;
	private SimpleLookupTable uniqueParameterizedGenericMethodBindings;
	
	public CompilationUnitDeclaration unitBeingCompleted = null; // only set while completing units


	this.uniqueParameterizedTypeBindings = new SimpleLookupTable(3);
	this.uniqueRawTypeBindings = new SimpleLookupTable(3);
	this.uniqueWildcardBindings = new SimpleLookupTable(3);
	this.uniqueParameterizedGenericMethodBindings = new SimpleLookupTable(3);
	this.accessRestrictions = new HashMap(3);
	
	this.classFilePool = ClassFilePool.newInstance();


	for (int i = this.lastCompletedUnitIndex + 1; i <= this.lastUnitIndex; i++) {
		CompilationUnitScope unitScope = (this.unitBeingCompleted = this.units[i]).scope;
		unitScope.checkParameterizedTypes();
		unitScope.buildFieldsAndMethods();
		this.units[i] = null; // release unnecessary reference to the parsed unit
	}


	(this.unitBeingCompleted = parsedUnit).scope.checkAndSetImports();
	parsedUnit.scope.connectTypeHierarchy();
	parsedUnit.scope.checkParameterizedTypes();	
	if (buildFieldsAndMethods)
		parsedUnit.scope.buildFieldsAndMethods();
	this.unitBeingCompleted = null;

	return packageBinding;
}

public ParameterizedGenericMethodBinding createParameterizedGenericMethod(MethodBinding genericMethod, RawTypeBinding rawType) {

	// cached info is array of already created parameterized types for this type
	ParameterizedGenericMethodBinding[] cachedInfo = (ParameterizedGenericMethodBinding[])this.uniqueParameterizedGenericMethodBindings.get(genericMethod);
	boolean needToGrow = false;
	int index = 0;
	if (cachedInfo != null){
		nextCachedMethod : 
			// iterate existing parameterized for reusing one with same type arguments if any
			for (int max = cachedInfo.length; index < max; index++){
				ParameterizedGenericMethodBinding cachedMethod = cachedInfo[index];
				if (cachedMethod == null) break nextCachedMethod;
				if (!cachedMethod.isRaw) continue nextCachedMethod;
				if (cachedMethod.declaringClass != (rawType == null ? genericMethod.declaringClass : rawType)) continue nextCachedMethod;
				return cachedMethod;
		}
		needToGrow = true;
	} else {
		cachedInfo = new ParameterizedGenericMethodBinding[5];
		this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
	}
	// grow cache ?
	int length = cachedInfo.length;
	if (needToGrow && index == length){
		System.arraycopy(cachedInfo, 0, cachedInfo = new ParameterizedGenericMethodBinding[length*2], 0, length);
		this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
	}
	// add new binding
	ParameterizedGenericMethodBinding parameterizedGenericMethod = new ParameterizedGenericMethodBinding(genericMethod, rawType, this);
	cachedInfo[index] = parameterizedGenericMethod;
	return parameterizedGenericMethod;
}

public ParameterizedGenericMethodBinding createParameterizedGenericMethod(MethodBinding genericMethod, TypeBinding[] typeArguments) {

	// cached info is array of already created parameterized types for this type
	ParameterizedGenericMethodBinding[] cachedInfo = (ParameterizedGenericMethodBinding[])this.uniqueParameterizedGenericMethodBindings.get(genericMethod);
	int argLength = typeArguments == null ? 0: typeArguments.length;
	boolean needToGrow = false;
	int index = 0;
	if (cachedInfo != null){
		nextCachedMethod : 
			// iterate existing parameterized for reusing one with same type arguments if any
			for (int max = cachedInfo.length; index < max; index++){
				ParameterizedGenericMethodBinding cachedMethod = cachedInfo[index];
				if (cachedMethod == null) break nextCachedMethod;
				if (cachedMethod.isRaw) continue nextCachedMethod;
				TypeBinding[] cachedArguments = cachedMethod.typeArguments;
				int cachedArgLength = cachedArguments == null ? 0 : cachedArguments.length;
				if (argLength != cachedArgLength) continue nextCachedMethod;
				for (int j = 0; j < cachedArgLength; j++){
					if (typeArguments[j] != cachedArguments[j]) continue nextCachedMethod;
				}
				// all arguments match, reuse current
				return cachedMethod;
		}
		needToGrow = true;
	} else {
		cachedInfo = new ParameterizedGenericMethodBinding[5];
		this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
	}
	// grow cache ?
	int length = cachedInfo.length;
	if (needToGrow && index == length){
		System.arraycopy(cachedInfo, 0, cachedInfo = new ParameterizedGenericMethodBinding[length*2], 0, length);
		this.uniqueParameterizedGenericMethodBindings.put(genericMethod, cachedInfo);
	}
	// add new binding
	ParameterizedGenericMethodBinding parameterizedGenericMethod = new ParameterizedGenericMethodBinding(genericMethod, typeArguments, this);
	cachedInfo[index] = parameterizedGenericMethod;
	return parameterizedGenericMethod;
}

public ParameterizedTypeBinding createParameterizedType(ReferenceBinding genericType, TypeBinding[] typeArguments, ReferenceBinding enclosingType) {

	// cached info is array of already created parameterized types for this type
	ParameterizedTypeBinding[] cachedInfo = (ParameterizedTypeBinding[])this.uniqueParameterizedTypeBindings.get(genericType);
	int argLength = typeArguments == null ? 0: typeArguments.length;
	boolean needToGrow = false;
	int index = 0;
	if (cachedInfo != null){
		nextCachedType : 
			// iterate existing parameterized for reusing one with same type arguments if any
			for (int max = cachedInfo.length; index < max; index++){
			    ParameterizedTypeBinding cachedType = cachedInfo[index];
			    if (cachedType == null) break nextCachedType;
			    if (cachedType.type != genericType) continue nextCachedType; // remain of unresolved type
			    if (cachedType.enclosingType() != enclosingType) continue nextCachedType;
				TypeBinding[] cachedArguments = cachedType.arguments;

		}
		needToGrow = true;
	} else {
		cachedInfo = new ParameterizedTypeBinding[5];
		this.uniqueParameterizedTypeBindings.put(genericType, cachedInfo);
	}
	// grow cache ?
	int length = cachedInfo.length;
	if (needToGrow && index == length){
		System.arraycopy(cachedInfo, 0, cachedInfo = new ParameterizedTypeBinding[length*2], 0, length);
		this.uniqueParameterizedTypeBindings.put(genericType, cachedInfo);
	}
	// add new binding
	ParameterizedTypeBinding parameterizedType = new ParameterizedTypeBinding(genericType,typeArguments, enclosingType, this);
	cachedInfo[index] = parameterizedType;
	return parameterizedType;
}


	// cached info is array of already created raw types for this type
	RawTypeBinding[] cachedInfo = (RawTypeBinding[])this.uniqueRawTypeBindings.get(genericType);
	boolean needToGrow = false;
	int index = 0;
	if (cachedInfo != null){
		nextCachedType : 
			// iterate existing parameterized for reusing one with same type arguments if any
			for (int max = cachedInfo.length; index < max; index++){
			    RawTypeBinding cachedType = cachedInfo[index];
			    if (cachedType == null) break nextCachedType;
			    if (cachedType.type != genericType) continue nextCachedType; // remain of unresolved type
			    if (cachedType.enclosingType() != enclosingType) continue nextCachedType;
				// all enclosing type match, reuse current

		this.uniqueRawTypeBindings.put(genericType, cachedInfo);
	}
	// grow cache ?
	int length = cachedInfo.length;
	if (needToGrow && index == length){
		System.arraycopy(cachedInfo, 0, cachedInfo = new RawTypeBinding[length*2], 0, length);
		this.uniqueRawTypeBindings.put(genericType, cachedInfo);
	}
	// add new binding
	RawTypeBinding rawType = new RawTypeBinding(genericType, enclosingType, this);
	cachedInfo[index] = rawType;
	return rawType;
	
}

		genericType = ReferenceBinding.LUB_GENERIC;
	WildcardBinding[] cachedInfo = (WildcardBinding[])this.uniqueWildcardBindings.get(genericType);
	boolean needToGrow = false;
	int index = 0;
	if (cachedInfo != null){
		nextCachedType : 
			// iterate existing wildcards for reusing one with same information if any
			for (int max = cachedInfo.length; index < max; index++){
			    WildcardBinding cachedType = cachedInfo[index];
			    if (cachedType == null) break nextCachedType;
			    if (cachedType.genericType != genericType) continue nextCachedType; // remain of unresolved type
			    if (cachedType.rank != rank) continue nextCachedType;
			    if (cachedType.boundKind != boundKind) continue nextCachedType;

		}
		needToGrow = true;
	} else {
		cachedInfo = new WildcardBinding[10];
		this.uniqueWildcardBindings.put(genericType, cachedInfo);
	}
	// grow cache ?
	int length = cachedInfo.length;
	if (needToGrow && index == length){
		System.arraycopy(cachedInfo, 0, cachedInfo = new WildcardBinding[length*2], 0, length);
		this.uniqueWildcardBindings.put(genericType, cachedInfo);
	}
	// add new binding
	WildcardBinding wildcard = new WildcardBinding(genericType, rank, bound, otherBounds, boundKind, this);
	cachedInfo[index] = wildcard;
	return wildcard;
}


	this.uniqueParameterizedTypeBindings = new SimpleLookupTable(3);
	this.uniqueRawTypeBindings = new SimpleLookupTable(3);
	this.uniqueWildcardBindings = new SimpleLookupTable(3);
	this.uniqueParameterizedGenericMethodBindings = new SimpleLookupTable(3);
	
	for (int i = this.units.length; --i >= 0;)
		this.units[i] = null;

Lines 54-60 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/RawTypeBinding.java (-1 / +1 lines)
54	if (originalMethod.typeVariables == Binding.NO_TYPE_VARIABLES \|\| originalMethod.isStatic()) {	54	if (originalMethod.typeVariables == Binding.NO_TYPE_VARIABLES \|\| originalMethod.isStatic()) {
55	return super.createParameterizedMethod(originalMethod);	55	return super.createParameterizedMethod(originalMethod);
56	}	56	}
57	return new ParameterizedGenericMethodBinding(originalMethod, this, this.environment);	57	return this.environment.createParameterizedGenericMethod(originalMethod, this);
58	}	58	}
59		59
60	public int kind() {	60	public int kind() {




		},
		"");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=108045
public void test0968() {
	this.runNegativeTest(
		new String[] {
			"X.java", //================================
			"import java.util.*;\n" + 
			"public class X<T0> extends ArrayList<T0> implements I<T0> {\n" + 
			"}\n" + 
			"interface I<T1> extends Collection {\n" + 
			"}\n"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	public class X<T0> extends ArrayList<T0> implements I<T0> {\n" + 
		"	             ^\n" + 
		"The interface Collection cannot be implemented more than once with different arguments: Collection<T0> and Collection\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 2)\n" + 
		"	public class X<T0> extends ArrayList<T0> implements I<T0> {\n" + 
		"	             ^\n" + 
		"The serializable class X does not declare a static final serialVersionUID field of type long\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 4)\n" + 
		"	interface I<T1> extends Collection {\n" + 
		"	                        ^^^^^^^^^^\n" + 
		"Collection is a raw type. References to generic type Collection<E> should be parameterized\n" + 
		"----------\n");
}
}

Return to bug 104293

Lines 6481-6488 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTConverter15Test.java (-2 / +3 lines)
6481		6481
6482	/*	6482	/*
6483	* Check unique instance of generic method bindings	6483	* Check unique instance of generic method bindings
		6484	* https://bugs.eclipse.org/bugs/show_bug.cgi?id=104293
6484	*/	6485	*/
6485	public void _test0214() throws JavaModelException {	6486	public void test0214() throws JavaModelException {
6486	this.workingCopy = getWorkingCopy("/Converter15/src/X.java", true/resolve/);	6487	this.workingCopy = getWorkingCopy("/Converter15/src/X.java", true/resolve/);
6487	String contents =	6488	String contents =
6488	"public class X {\n" +	6489	"public class X {\n" +
Lines 6529-6535 Link Here
6529	invocation = (MethodInvocation) expression;	6530	invocation = (MethodInvocation) expression;
6530	IMethodBinding methodBinding2 = invocation.resolveMethodBinding();	6531	IMethodBinding methodBinding2 = invocation.resolveMethodBinding();
6531		6532
6532	assertTrue("Not equals", methodBinding == methodBinding2);	6533	assertTrue("Not identical", methodBinding == methodBinding2);
6533	}	6534	}
6534		6535
6535	}	6536	}

Lines 46-52 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java (-4 / +4 lines)
46	// incompatible due to wrong arity	46	// incompatible due to wrong arity
47	return new ProblemMethodBinding(originalMethod, originalMethod.selector, substitutes, ProblemReasons.TypeParameterArityMismatch);	47	return new ProblemMethodBinding(originalMethod, originalMethod.selector, substitutes, ProblemReasons.TypeParameterArityMismatch);
48	}	48	}
49	methodSubstitute = new ParameterizedGenericMethodBinding(originalMethod, substitutes, scope.environment());	49	methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, substitutes);
50	break computeSubstitutes;	50	break computeSubstitutes;
51	}	51	}
52		52
Lines 172-178 Link Here
172	return null; // incompatible	172	return null; // incompatible
173	if (substitutes.length == 0) {	173	if (substitutes.length == 0) {
174	// raw generic method inferred	174	// raw generic method inferred
175	return new ParameterizedGenericMethodBinding(originalMethod, (RawTypeBinding)null, scope.environment());	175	return scope.environment().createParameterizedGenericMethod(originalMethod, (RawTypeBinding)null);
176	}	176	}
177	// apply inferred variable substitutions - replacing unresolved variable with original ones in param method	177	// apply inferred variable substitutions - replacing unresolved variable with original ones in param method
178	TypeBinding[] resolvedSubstitutes = substitutes;	178	TypeBinding[] resolvedSubstitutes = substitutes;
Lines 186-192 Link Here
186	resolvedSubstitutes[i] = substitutes[i];	186	resolvedSubstitutes[i] = substitutes[i];
187	}	187	}
188	}	188	}
189	return new ParameterizedGenericMethodBinding(originalMethod, resolvedSubstitutes, scope.environment());	189	return scope.environment().createParameterizedGenericMethod(originalMethod, resolvedSubstitutes);
190	}	190	}
191		191
192	private static TypeBinding[] resolveSubstituteConstraints(Scope scope, TypeVariableBinding[] typeVariables, TypeBinding[] substitutes, boolean considerEXTENDSConstraints, Map collectedSubstitutes) {	192	private static TypeBinding[] resolveSubstituteConstraints(Scope scope, TypeVariableBinding[] typeVariables, TypeBinding[] substitutes, boolean considerEXTENDSConstraints, Map collectedSubstitutes) {
Lines 493-499 Link Here
493	TypeBinding[] rawArguments = new TypeBinding[length];	493	TypeBinding[] rawArguments = new TypeBinding[length];
494	for (int i = 0; i < length; i++)	494	for (int i = 0; i < length; i++)
495	rawArguments[i] = environment.convertToRawType(originalVariables[i].erasure());	495	rawArguments[i] = environment.convertToRawType(originalVariables[i].erasure());
496	this.tiebreakMethod = new ParameterizedGenericMethodBinding(this.originalMethod, rawArguments, this.environment);	496	this.tiebreakMethod = this.environment.createParameterizedGenericMethod(this.originalMethod, rawArguments);
497	// }	497	// }
498	}	498	}
499	return this.tiebreakMethod;	499	return this.tiebreakMethod;

Lines 192-204 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java (-2 / +6 lines)
192	System.arraycopy(resolvedImports, 0, resolvedImports = new ImportBinding[index], 0, index);	192	System.arraycopy(resolvedImports, 0, resolvedImports = new ImportBinding[index], 0, index);
193	imports = resolvedImports;	193	imports = resolvedImports;
194	}	194	}
195	void checkParameterizedTypeBounds() {	195
		196	/**
		197	* Perform deferred check specific to parameterized types: bound checks, supertype collisions
		198	*/
		199	void checkParameterizedTypes() {
196	if (compilerOptions().sourceLevel < ClassFileConstants.JDK1_5) return;	200	if (compilerOptions().sourceLevel < ClassFileConstants.JDK1_5) return;
197		201
198	for (int i = 0, length = topLevelTypes.length; i < length; i++) {	202	for (int i = 0, length = topLevelTypes.length; i < length; i++) {
199	ClassScope scope = topLevelTypes[i].scope;	203	ClassScope scope = topLevelTypes[i].scope;
200	scope.checkParameterizedTypeBounds();	204	scope.checkParameterizedTypeBounds();
201	scope.checkForErasedCandidateCollisions();	205	scope.checkParameterizedSuperTypeCollisions();
202	}	206	}
203	}	207	}
204	/*	208	/*

Lines 30407-30410 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java (+28 lines)
30407	},	30407	},
30408	"");	30408	"");
30409	}	30409	}
		30410	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=108045
		30411	public void test0968() {
		30412	this.runNegativeTest(
		30413	new String[] {
		30414	"X.java", //================================
		30415	"import java.util.*;\n" +
		30416	"public class X<T0> extends ArrayList<T0> implements I<T0> {\n" +
		30417	"}\n" +
		30418	"interface I<T1> extends Collection {\n" +
		30419	"}\n"
		30420	},
		30421	"----------\n" +
		30422	"1. ERROR in X.java (at line 2)\n" +
		30423	" public class X<T0> extends ArrayList<T0> implements I<T0> {\n" +
		30424	" ^\n" +
		30425	"The interface Collection cannot be implemented more than once with different arguments: Collection<T0> and Collection\n" +
		30426	"----------\n" +
		30427	"2. WARNING in X.java (at line 2)\n" +
		30428	" public class X<T0> extends ArrayList<T0> implements I<T0> {\n" +
		30429	" ^\n" +
		30430	"The serializable class X does not declare a static final serialVersionUID field of type long\n" +
		30431	"----------\n" +
		30432	"3. WARNING in X.java (at line 4)\n" +
		30433	" interface I<T1> extends Collection {\n" +
		30434	" ^^^^^^^^^^\n" +
		30435	"Collection is a raw type. References to generic type Collection<E> should be parameterized\n" +
		30436	"----------\n");
		30437	}
30410	}	30438	}

Lines 37-43 Link Here

(-)model/org/eclipse/jdt/internal/core/util/BindingKeyResolver.java (-3 / +2 lines)
37	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;	37	import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
38	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;	38	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
39	import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;	39	import org.eclipse.jdt.internal.compiler.lookup.PackageBinding;
40	import org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding;
41	import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;	40	import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
42	import org.eclipse.jdt.internal.compiler.lookup.RawTypeBinding;	41	import org.eclipse.jdt.internal.compiler.lookup.RawTypeBinding;
43	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;	42	import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
Lines 204-212 Link Here
204	return;	203	return;
205	TypeBinding[] arguments = getTypeBindingArguments();	204	TypeBinding[] arguments = getTypeBindingArguments();
206	if (arguments.length != this.methodBinding.typeVariables().length)	205	if (arguments.length != this.methodBinding.typeVariables().length)
207	this.methodBinding = new ParameterizedGenericMethodBinding(this.methodBinding, (RawTypeBinding) null, this.environment);	206	this.methodBinding = this.environment.createParameterizedGenericMethod(this.methodBinding, (RawTypeBinding) null);
208	else	207	else
209	this.methodBinding = new ParameterizedGenericMethodBinding(this.methodBinding, arguments, this.environment);	208	this.methodBinding = this.environment.createParameterizedGenericMethod(this.methodBinding, arguments);
210	this.compilerBinding = this.methodBinding;	209	this.compilerBinding = this.methodBinding;
211	}	210	}
212		211