Attachment #193918 for bug #339478

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.*;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;

public class AllocationExpression extends Expression implements InvocationSite {


		// initialization of an enum constant
		this.resolvedType = scope.enclosingReceiverType();
	} else {
		this.resolvedType = this.type.resolveType(scope, true /* check bounds*/);
			this.resolvedType = null; // can be done only after type arguments and method arguments resolution.
		} else {
			this.resolvedType = this.type.resolveType(scope, true /* check bounds*/);
		}
		// check for parameterized allocation deferred to below.
	}
	// will check for null after args are resolved

			return this.resolvedType;
		}
	}
	if (this.resolvedType == null || !this.resolvedType.isValidBinding()) {
		return null;
	}

	// null type denotes fake allocation for enum constant inits
	if (this.type != null && !this.resolvedType.canBeInstantiated()) {
		scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
		return this.resolvedType;
	}
	if (this.type != null && this.resolvedType != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
		TypeBinding [] inferredTypes = inferElidedTypes(((ParameterizedTypeBinding) this.resolvedType).genericType(), argumentTypes, scope);
		this.resolvedType = this.type.resolvedType = scope.environment().createParameterizedType(((ParameterizedTypeBinding) this.resolvedType).genericType(), inferredTypes, ((ParameterizedTypeBinding) this.resolvedType).enclosingType());
		// inject inferred args ??
	}
	checkParameterizedAllocation: {
		if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()

			}
		}
	}
	if (this.resolvedType == null || !this.resolvedType.isValidBinding()) {
		return null;
	}

	// null type denotes fake allocation for enum constant inits
	if (this.type != null && !this.resolvedType.canBeInstantiated()) {
		scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
		return this.resolvedType;
	}
	ReferenceBinding allocationType = (ReferenceBinding) this.resolvedType;
	if (!(this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {
		if (this.binding.declaringClass == null) {

	return allocationType;
}

public TypeBinding[] inferElidedTypes(ReferenceBinding allocationType, TypeBinding[] argumentTypes, final BlockScope scope) {
	MethodBinding factory = getStaticFactory(allocationType, argumentTypes, scope);
	if (factory instanceof ParameterizedGenericMethodBinding) {
		return ((ParameterizedTypeBinding)factory.returnType).arguments;
	}
	int arity = allocationType.typeVariables().length;
	TypeBinding [] inferredTypes = new TypeBinding[arity];
	for (int i = 0; i < arity; i++) {
		inferredTypes[i] = new ProblemReferenceBinding(CharOperation.NO_CHAR_CHAR, null, ProblemReasons.InferenceFailed);
	}
	return inferredTypes;
}

private MethodBinding getStaticFactory (ReferenceBinding allocationType, TypeBinding[] argumentTypes, final BlockScope scope) {
	TypeVariableBinding[] classTypeVariables = allocationType.typeVariables();
	int classTypeVariablesArity = classTypeVariables.length;
	MethodBinding[] methods = allocationType.getMethods(TypeConstants.INIT, argumentTypes.length);
	MethodBinding [] staticFactories = new MethodBinding[methods.length];
	int sfi = 0;
	for (int i = 0, length = methods.length; i < length; i++) {
		MethodBinding method = methods[i];
		
		TypeVariableBinding[] methodTypeVariables = method.typeVariables();
		int methodTypeVariablesArity = methodTypeVariables.length;

		if (this.genericTypeArguments != null && this.genericTypeArguments.length < methodTypeVariablesArity)
			continue; // wrong tree, don't bark.
		MethodBinding staticFactory = new MethodBinding(method.modifiers | ClassFileConstants.AccStatic, TypeConstants.SYNTHETIC_STATIC_FACTORY,
																	null, null, null, method.declaringClass);
		staticFactory.typeVariables = new TypeVariableBinding[classTypeVariablesArity + (this.genericTypeArguments == null ? methodTypeVariablesArity : 0)];
		final SimpleLookupTable map = new SimpleLookupTable(classTypeVariablesArity + methodTypeVariablesArity);
		// Rename each type variable T of the type to T'
		for (int j = 0; j < classTypeVariablesArity; j++) {
			map.put(classTypeVariables[j], staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(classTypeVariables[j].sourceName, "'".toCharArray()), //$NON-NLS-1$
																		staticFactory, j, scope.environment()));
		}
		// Rename each type variable U of method U to U'' if not explicitly parameterized. Otherwise use the parameterizing type.
		for (int j = classTypeVariablesArity, max = classTypeVariablesArity + methodTypeVariablesArity; j < max; j++) {
			map.put(methodTypeVariables[j - classTypeVariablesArity], 
					this.genericTypeArguments != null ? this.genericTypeArguments[j - classTypeVariablesArity] :
						(staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(methodTypeVariables[j - classTypeVariablesArity].sourceName, "''".toCharArray()), //$NON-NLS-1$
																		staticFactory, j, scope.environment())));
		}
		
		Substitution substitution = new Substitution() {
				public LookupEnvironment environment() {
					return scope.environment();
				}
				public boolean isRawSubstitution() {
					return false;
				}
				public TypeBinding substitute(TypeVariableBinding typeVariable) {
					return (TypeBinding) map.get(typeVariable);
				}
			};

		staticFactory.parameters = Scope.substitute(substitution, method.parameters);
		
		// initialize new variable bounds
		for (int j = 0, max = classTypeVariablesArity + methodTypeVariablesArity; j < max; j++) {
			TypeVariableBinding originalVariable = j < classTypeVariablesArity ? classTypeVariables[j] : methodTypeVariables[j - classTypeVariablesArity];
			TypeBinding substitutedType = (TypeBinding) map.get(originalVariable);
			if (substitutedType instanceof TypeVariableBinding) {
				TypeVariableBinding substitutedVariable = (TypeVariableBinding) substitutedType;
				TypeBinding substitutedSuperclass = Scope.substitute(substitution, originalVariable.superclass);
				ReferenceBinding[] substitutedInterfaces = Scope.substitute(substitution, originalVariable.superInterfaces);
				if (originalVariable.firstBound != null) {
					substitutedVariable.firstBound = originalVariable.firstBound == originalVariable.superclass
							? substitutedSuperclass // could be array type or interface
									: substitutedInterfaces[0];
				}
				switch (substitutedSuperclass.kind()) {
					case Binding.ARRAY_TYPE :
						substitutedVariable.superclass = scope.environment().getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
						substitutedVariable.superInterfaces = substitutedInterfaces;
						break;
					default:
						if (substitutedSuperclass.isInterface()) {
							substitutedVariable.superclass = scope.environment().getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
							int interfaceCount = substitutedInterfaces.length;
							System.arraycopy(substitutedInterfaces, 0, substitutedInterfaces = new ReferenceBinding[interfaceCount+1], 1, interfaceCount);
							substitutedInterfaces[0] = (ReferenceBinding) substitutedSuperclass;
							substitutedVariable.superInterfaces = substitutedInterfaces;
						} else {
							substitutedVariable.superclass = (ReferenceBinding) substitutedSuperclass; // typeVar was extending other typeVar which got substituted with interface
							substitutedVariable.superInterfaces = substitutedInterfaces;
						}
				}
			}
		}
	    TypeVariableBinding[] returnTypeParameters = new TypeVariableBinding[classTypeVariablesArity];
		for (int j = 0; j < classTypeVariablesArity; j++) {
			returnTypeParameters[j] = (TypeVariableBinding) map.get(classTypeVariables[j]);
		}
		staticFactory.returnType = scope.environment().createParameterizedType(allocationType, returnTypeParameters, allocationType.enclosingType());
		staticFactory.thrownExceptions = Scope.substitute(substitution, method.thrownExceptions);
		if (staticFactory.thrownExceptions == null) { 
			staticFactory.thrownExceptions = Binding.NO_EXCEPTIONS;
		}
		staticFactories[sfi++] = new ParameterizedMethodBinding((ParameterizedTypeBinding) scope.environment().convertToParameterizedType(staticFactory.declaringClass),
																											staticFactory);
	}
	if (sfi != methods.length) {
		System.arraycopy(staticFactories, 0, staticFactories = new MethodBinding[sfi], 0, sfi);
	}
	final InvocationSite allocationSite = this;
	InvocationSite site = new InvocationSite() { // Alternate site to not expose the generic type arguments as they have already been substituted.
		public int sourceStart() { return allocationSite.sourceStart(); }
		public int sourceEnd() { return allocationSite.sourceEnd(); }
		public void setFieldIndex(int depth) {	allocationSite.setFieldIndex(depth);	}
		public void setDepth(int depth) { allocationSite.setDepth(depth);}
		public void setActualReceiverType(ReferenceBinding receiverType) { allocationSite.setActualReceiverType(receiverType);}
		public boolean isTypeAccess() { return allocationSite.isTypeAccess(); }
		public boolean isSuperAccess() { return allocationSite.isSuperAccess(); }
		public TypeBinding[] genericTypeArguments() { return null; }
		public TypeBinding expectedType() { return allocationSite.expectedType(); }
	};
	MethodBinding[] compatible = new MethodBinding[sfi];
	int compatibleIndex = 0;
	for (int i = 0; i < sfi; i++) {
		MethodBinding compatibleMethod = scope.computeCompatibleMethod(staticFactories[i], argumentTypes, site);
		if (compatibleMethod != null) {
			if (compatibleMethod.isValidBinding())
				compatible[compatibleIndex++] = compatibleMethod;
		}
	}

	if (compatibleIndex == 0) {
		return null;
	}
	MethodBinding[] visible = new MethodBinding[compatibleIndex];
	int visibleIndex = 0;
	for (int i = 0; i < compatibleIndex; i++) {
		MethodBinding method = compatible[i];
		if (method.canBeSeenBy(this, scope))
			visible[visibleIndex++] = method;
	}
	if (visibleIndex == 0) {
		return null;
	}
	return visibleIndex == 1 ? visible[0] : scope.mostSpecificMethodBinding(visible, visibleIndex, argumentTypes, this, allocationType);
}

public void setActualReceiverType(ReferenceBinding receiverType) {
	// ignored
}

Lines 268-274 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java (-1 / +1 lines)
268	// check argument type compatibility	268	// check argument type compatibility
269	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution	269	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution
270	parameterizedType.boundCheck(scope, args);	270	parameterizedType.boundCheck(scope, args);
271	else	271	else if (!isDiamond)
272	scope.deferBoundCheck(this);	272	scope.deferBoundCheck(this);
273	qualifyingType = parameterizedType;	273	qualifyingType = parameterizedType;
274	} else {	274	} else {

Lines 245-251 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (-1 / +1 lines)
245	// check argument type compatibility	245	// check argument type compatibility
246	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution	246	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution
247	parameterizedType.boundCheck(scope, this.typeArguments);	247	parameterizedType.boundCheck(scope, this.typeArguments);
248	else	248	else if ((this.bits & ASTNode.IsDiamond) == 0)
249	scope.deferBoundCheck(this);	249	scope.deferBoundCheck(this);
250	if (isTypeUseDeprecated(parameterizedType, scope))	250	if (isTypeUseDeprecated(parameterizedType, scope))
251	reportDeprecatedType(parameterizedType, scope);	251	reportDeprecatedType(parameterizedType, scope);




import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReferenceBinding;

				// initialization of an enum constant
				receiverType = scope.enclosingSourceType();
			} else {
				receiverType = this.type.resolveType(scope, true /* check bounds*/);
				checkParameterizedAllocation: {
					if (receiverType == null || !receiverType.isValidBinding()) break checkParameterizedAllocation;
					if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
						ReferenceBinding currentType = (ReferenceBinding)receiverType;
						do {
							// isStatic() is answering true for toplevel types
							if ((currentType.modifiers & ClassFileConstants.AccStatic) != 0) break checkParameterizedAllocation;
							if (currentType.isRawType()) break checkParameterizedAllocation;
						} while ((currentType = currentType.enclosingType())!= null);
						ParameterizedQualifiedTypeReference qRef = (ParameterizedQualifiedTypeReference) this.type;
						for (int i = qRef.typeArguments.length - 2; i >= 0; i--) {
							if (qRef.typeArguments[i] != null) {
								scope.problemReporter().illegalQualifiedParameterizedTypeAllocation(this.type, receiverType);
								break;
							}
						}
					}
				}
				// check for parameterized allocation deferred to below.
			}
		}
		if (receiverType == null || !receiverType.isValidBinding()) {
			hasError = true;
		}

		// resolve type arguments (for generic constructor call)
		if (this.typeArguments != null) {

				}
			}
		}
		if (this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
			// Perform diamond inference here. (Not done yet.)
			receiverType = this.type.resolveType(scope, true /* check bounds*/); // for now just do what we do for 1.6-
		}	
		checkParameterizedAllocation: {
			if (receiverType == null || !receiverType.isValidBinding()) break checkParameterizedAllocation;
			if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
				ReferenceBinding currentType = (ReferenceBinding)receiverType;
				do {
					// isStatic() is answering true for toplevel types
					if ((currentType.modifiers & ClassFileConstants.AccStatic) != 0) break checkParameterizedAllocation;
					if (currentType.isRawType()) break checkParameterizedAllocation;
				} while ((currentType = currentType.enclosingType())!= null);
				ParameterizedQualifiedTypeReference qRef = (ParameterizedQualifiedTypeReference) this.type;
				for (int i = qRef.typeArguments.length - 2; i >= 0; i--) {
					if (qRef.typeArguments[i] != null) {
						scope.problemReporter().illegalQualifiedParameterizedTypeAllocation(this.type, receiverType);
						break;
					}
				}
			}
		}
		if (receiverType == null || !receiverType.isValidBinding()) {
			hasError = true;
		}

		// limit of fault-tolerance
		if (hasError) {

				scope.problemReporter().cannotInstantiate(this.type, receiverType);
				return this.resolvedType = receiverType;
			}
			if (this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
				TypeBinding [] inferredTypes = inferElidedTypes(((ParameterizedTypeBinding) receiverType).genericType(), argumentTypes, scope);
				receiverType = this.type.resolvedType = scope.environment().createParameterizedType(((ParameterizedTypeBinding) receiverType).genericType(), inferredTypes, ((ParameterizedTypeBinding) receiverType).enclosingType());
			}
			ReferenceBinding allocationType = (ReferenceBinding) receiverType;
			if ((this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {
				if (isMethodUseDeprecated(this.binding, scope, true)) {

Lines 31-34 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ProblemReasons.java (+1 lines)
31	final int TypeArgumentsForRawGenericMethod = 13; // for generic method	31	final int TypeArgumentsForRawGenericMethod = 13; // for generic method
32	final int InvalidTypeForStaticImport = 14;	32	final int InvalidTypeForStaticImport = 14;
33	final int InvalidTypeForAutoManagedResource = 15;	33	final int InvalidTypeForAutoManagedResource = 15;
		34	final int InferenceFailed = 16;
34	}	35	}

Lines 511-517 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java (-2 / +2 lines)
511	* Will answer a substituted method in case the method was generic and type inference got triggered;	511	* Will answer a substituted method in case the method was generic and type inference got triggered;
512	* in case the method was originally compatible, then simply answer it back.	512	* in case the method was originally compatible, then simply answer it back.
513	*/	513	*/
514	protected final MethodBinding computeCompatibleMethod(MethodBinding method, TypeBinding[] arguments, InvocationSite invocationSite) {	514	public final MethodBinding computeCompatibleMethod(MethodBinding method, TypeBinding[] arguments, InvocationSite invocationSite) {
515	TypeBinding[] genericTypeArguments = invocationSite.genericTypeArguments();	515	TypeBinding[] genericTypeArguments = invocationSite.genericTypeArguments();
516	TypeBinding[] parameters = method.parameters;	516	TypeBinding[] parameters = method.parameters;
517	TypeVariableBinding[] typeVariables = method.typeVariables;	517	TypeVariableBinding[] typeVariables = method.typeVariables;
Lines 3686-3692 Link Here
3686	}	3686	}
3687		3687
3688	// caveat: this is not a direct implementation of JLS	3688	// caveat: this is not a direct implementation of JLS
3689	protected final MethodBinding mostSpecificMethodBinding(MethodBinding[] visible, int visibleSize, TypeBinding[] argumentTypes, final InvocationSite invocationSite, ReferenceBinding receiverType) {	3689	public final MethodBinding mostSpecificMethodBinding(MethodBinding[] visible, int visibleSize, TypeBinding[] argumentTypes, final InvocationSite invocationSite, ReferenceBinding receiverType) {
3690	int[] compatibilityLevels = new int[visibleSize];	3690	int[] compatibilityLevels = new int[visibleSize];
3691	for (int i = 0; i < visibleSize; i++)	3691	for (int i = 0; i < visibleSize; i++)
3692	compatibilityLevels[i] = parameterCompatibilityLevel(visible[i], argumentTypes);	3692	compatibilityLevels[i] = parameterCompatibilityLevel(visible[i], argumentTypes);

Lines 170-175 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeConstants.java (+1 lines)
170	char[] SYNTHETIC_ENCLOSING_INSTANCE_PREFIX = "this$".toCharArray(); //$NON-NLS-1$	170	char[] SYNTHETIC_ENCLOSING_INSTANCE_PREFIX = "this$".toCharArray(); //$NON-NLS-1$
171	char[] SYNTHETIC_ACCESS_METHOD_PREFIX = "access$".toCharArray(); //$NON-NLS-1$	171	char[] SYNTHETIC_ACCESS_METHOD_PREFIX = "access$".toCharArray(); //$NON-NLS-1$
172	char[] SYNTHETIC_ENUM_CONSTANT_INITIALIZATION_METHOD_PREFIX = " enum constant initialization$".toCharArray(); //$NON-NLS-1$	172	char[] SYNTHETIC_ENUM_CONSTANT_INITIALIZATION_METHOD_PREFIX = " enum constant initialization$".toCharArray(); //$NON-NLS-1$
		173	char[] SYNTHETIC_STATIC_FACTORY = "<factory>".toCharArray(); //$NON-NLS-1$
173		174
174	// synthetic package-info name	175	// synthetic package-info name
175	public static final char[] PACKAGE_INFO_NAME = "package-info".toCharArray(); //$NON-NLS-1$	176	public static final char[] PACKAGE_INFO_NAME = "package-info".toCharArray(); //$NON-NLS-1$




public class GenericsRegressionTest_1_7 extends AbstractRegressionTest {

static {
//	TESTS_NAMES = new String[] { "test0025" };
//	TESTS_NUMBERS = new int[] { 40, 41, 43, 45, 63, 64 };
//	TESTS_RANGE = new int[] { 11, -1 };
}

public static Test suite() {
	return buildMinimalComplianceTestSuite(testClass(), F_1_7);
}
public void test001() {
	this.runConformTest(
		new String[] {
			"X.java",

		},
		"SUCCESS");
}
public void test001a() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"The method testFunction(String) in the type X<String> is not applicable for the arguments (int)\n" + 
		"----------\n");
}
public void test001b() {
	this.runConformTest(
		new String[] {
			"X.java",

		"SUCCESS");
}
// fields
public void test001b_1() {
	this.runConformTest(
		new String[] {
			"X.java",

		},
		"SUCCESS");
}
public void test001c() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"----------\n");
}
// fields
public void test001c_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)\n" + 
		"----------\n");
}
public void test001d() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Object>)\n" + 
		"----------\n");
}
public void test001e() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Object>)\n" + 
		"----------\n");
}
public void test001f() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +

			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 2)\n" + 
		"	class X2<T>{\n" + 
		"	         ^\n" + 
		"The type parameter T is hiding the type T\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	X<String>.X2<String> x = new X<>().new X2<>();\n" + 
		"	                         ^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from X<Object>.X2<String> to X<String>.X2<String>\n" + 
		"----------\n");
}
// fields
public void test001f_1() {

		},
		"SUCCESS");
}
public void test001g() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +

			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 9)\n" + 
		"	X<String>.X2<Integer> x = new X<>().new X2<>();\n" + 
		"	                          ^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from X<Object>.X2<Integer> to X<String>.X2<Integer>\n" + 
		"----------\n");
}
public void test001g_1() {
	this.runConformTest(

		},
		"SUCCESS\n1");
}
public void test001h() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"	         ^\n" + 
		"The type parameter T is hiding the type T\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	X<String>.X2<String> x = new X<>().new X2<>();\n" + 
		"	                         ^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from X<Object>.X2<String> to X<String>.X2<String>\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 9)\n" + 
		"	x.methodx(1);\n" + 
		"	  ^^^^^^^\n" + 
		"The method methodx(String) in the type X<String>.X2<String> is not applicable for the arguments (int)\n" + 
		"----------\n");
}
public void test001h_1() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"Type safety: The method methodx(Object) belongs to the raw type X.X2. References to generic type X<T>.X2<T> should be parameterized\n" + 
		"----------\n");
}
public void test001h_2() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<T>{\n" +
			"		void methodx(T param){\n" +
			"			System.out.println(param);\n" +
			"		}\n" +
			"	}\n" +
			"	X<String>.X2<String> x;\n" + 
			"	public static void main(String[] args) {\n" +
			"		X test = new X();\n" + 
			"		test.x = new X<>().new X2<>();\n" + 
			"		test.x.methodx(1);\n" + 
			"	}\n" +
			"}",
		},
		"1");
}
public void test001i() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	class X2<K>{\n" +
			"		class X22<I>{\n" +
			"			void methodx(T param, K param2, I param3){\n" +

			"	}\n" +
			"}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 10)\n" + 
		"	X<String> test = new X<>();		X<String>.X2<Integer>.X22<X<String>> x = new X<>().new X2<>().new X22<>();\n" + 
		"	                           		                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from X<Object>.X2<Object>.X22<X<String>> to X<String>.X2<Integer>.X22<X<String>>\n" + 
		"----------\n");
}
public void test002() {
	this.runNegativeTest(

		"Type safety: The method testFunction(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" + 
		"----------\n");
}
public void test003() {
	this.runConformTest(
		new String[] {
			"X.java",

		"SUCCESS");
}

public void test004b() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"1");
}

public void test006() {
	this.runConformTest(
		new String[] {
			"X.java",

		"SUCCESS");
}
// shows the difference between using <> and the raw type - different semantics
public void test007() {
	this.runConformTest(
		new String[] {
			"X.java",

		"1\n" + 
		"2");
}
public void test007a() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"----------\n");
}
//shows the difference between using <> and the raw type - different semantics
public void test008() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X<T> {\n" +
			"	T field1;\n" +
			"	public X(T param){\n" +
			"		field1 = param;\n" +
			"	}\n" +

			"	}\n" + 
			"}",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 7)\n" + 
		"	X<?> x1 = new X(1).get(\"\");\n" + 
		"	          ^^^^^^^^\n" + 
		"Type safety: The constructor X(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 7)\n" + 
		"	X<?> x1 = new X(1).get(\"\");\n" + 
		"	          ^^^^^^^^^^^^^^^^\n" + 
		"Type safety: The method get(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 7)\n" + 
		"	X<?> x1 = new X(1).get(\"\");\n" + 
		"	              ^\n" + 
		"X is a raw type. References to generic type X<T> should be parameterized\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 8)\n" + 
		"	X<?> x2 = new X<>(1).get(\"\");\n" + 
		"	                     ^^^\n" + 
		"The method get(Integer) in the type X<Integer> is not applicable for the arguments (String)\n" + 
		"----------\n");
}

public void test0014() {
	this.runConformTest(
		new String[] {
			"X.java",

		"SUCCESS\n" +
		"123");
}
public void test0014a() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"The method testFunction(String, Integer) in the type X<String,Integer> is not applicable for the arguments (int, String)\n" + 
		"----------\n");
}
public void test0015() {
	this.runConformTest(
		new String[] {
			"X.java",

}
// To verify that a parameterized invocation of a generic constructor works even if <> is used
// to elide class type parameters.
public void test0016() {
	this.runConformTest(  // javac fails to compile this, looks buggy
		new String[] {
			"X.java",
			"public class X<T> {\n" +

}
// To verify that a parameterized invocation of a generic constructor works even if <> is used
// to elide class type parameters. This test handles fields
public void test0016b() {
	this.runConformTest(  // javac fails to compile this, looks buggy
		new String[] {
			"X.java",
			"public class X<T> {\n" +

// To verify that a parameterized invocation of a non-generic constructor works even if <> is used
// to elide class type parameters.
// This was not allowed in java 1.6 and 1.5 (https://bugs.eclipse.org/bugs/show_bug.cgi?id=168230)
public void test0017() {
	this.runConformTest( // javac fails to compile this, looks buggy
		new String[] {
			"X.java",
			"public class X<T> {\n" +

		"const.1\nconst.1\nconst.2");
}
// To verify that the correct constructor is found by parameter substitution in the diamond case
public void test0018() {
	this.runConformTest(
		new String[] {
			"X.java",

}
// To verify that the correct constructor is found by parameter substitution 
// in the diamond case -- fields
public void test0018b() {
	this.runConformTest(
		new String[] {
			"X.java",

		"----------\n");
}
// check inference at method argument position.
public void test0020() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"----------\n");
}
//check inference at method argument position.
public void test0021() {
	this.runNegativeTest(
		new String[] {
			"X.java",

		"The method f(List<String>) in the type X<T> is not applicable for the arguments (ArrayList<Object>)\n" + 
		"----------\n");
}
public void test0022() {
	this.runConformTest(
		new String[] {
			"X.java",
			"import java.util.HashMap;\n" +
			"import java.util.Map;\n" +
			"\n" +
			"class StringKeyHashMap<V> extends HashMap<String, V>  {  \n" +
			"}\n" +
			"\n" +
			"class IntegerValueHashMap<K> extends HashMap<K, Integer>  {  \n" +
			"}\n" +
			"\n" +
			"public class X {\n" +
			"    Map<String, Integer> m1 = new StringKeyHashMap<>();\n" +
			"    Map<String, Integer> m2 = new IntegerValueHashMap<>();\n" +
			"}\n"
		},
		"");
}
public void test0023() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.HashMap;\n" +
			"import java.util.Map;\n" +
			"\n" +
			"class StringKeyHashMap<V> extends HashMap<String, V>  {  \n" +
			"}\n" +
			"\n" +
			"class IntegerValueHashMap<K> extends HashMap<K, Integer>  {  \n" +
			"}\n" +
			"\n" +
			"public class X {\n" +
			"    Map<String, Integer> m1 = new StringKeyHashMap<>(10);\n" +
			"    Map<String, Integer> m2 = new IntegerValueHashMap<>();\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\n" + 
		"	class StringKeyHashMap<V> extends HashMap<String, V>  {  \n" + 
		"	      ^^^^^^^^^^^^^^^^\n" + 
		"The serializable class StringKeyHashMap does not declare a static final serialVersionUID field of type long\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 7)\n" + 
		"	class IntegerValueHashMap<K> extends HashMap<K, Integer>  {  \n" + 
		"	      ^^^^^^^^^^^^^^^^^^^\n" + 
		"The serializable class IntegerValueHashMap does not declare a static final serialVersionUID field of type long\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 11)\n" + 
		"	Map<String, Integer> m1 = new StringKeyHashMap<>(10);\n" + 
		"	                          ^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"The constructor StringKeyHashMap<>(int) is undefined\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 11)\n" + 
		"	Map<String, Integer> m1 = new StringKeyHashMap<>(10);\n" + 
		"	                          ^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from StringKeyHashMap<> to Map<String,Integer>\n" + 
		"----------\n");
}
// check inference at return expression.
public void test0024() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.List;\n" +
			"import java.util.ArrayList;\n" +
			"class X<T> {\n" +
			"  public X() {}\n" +
			"  X<String> f(List<String> p) {return new X<>();}\n" +
			"}\n",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 2)\n" + 
		"	import java.util.ArrayList;\n" + 
		"	       ^^^^^^^^^^^^^^^^^^^\n" + 
		"The import java.util.ArrayList is never used\n" + 
		"----------\n");
}
// check inference at cast expression.
public void test0025() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.List;\n" +
			"import java.util.ArrayList;\n" +
			"class X<T> {\n" +
			"  public X() {}\n" +
			"  void f(List<String> p) { Object o = (X<String>) new X<>();}\n" +
			"}\n",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 5)\n" + 
		"	void f(List<String> p) { Object o = (X<String>) new X<>();}\n" + 
		"	                                    ^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Cannot cast from X<Object> to X<String>\n" + 
		"----------\n");
}
public static Class testClass() {
	return GenericsRegressionTest_1_7.class;
}

Return to bug 339478

Lines 27-32 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedAllocationExpression.java (-30 / +26 lines)
27	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;	27	import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
28	import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;	28	import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;
29	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;	29	import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
		30	import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
30	import org.eclipse.jdt.internal.compiler.lookup.ProblemMethodBinding;	31	import org.eclipse.jdt.internal.compiler.lookup.ProblemMethodBinding;
31	import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;	32	import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
32	import org.eclipse.jdt.internal.compiler.lookup.ProblemReferenceBinding;	33	import org.eclipse.jdt.internal.compiler.lookup.ProblemReferenceBinding;
Lines 275-288 Link Here
275	// initialization of an enum constant	276	// initialization of an enum constant
276	receiverType = scope.enclosingSourceType();	277	receiverType = scope.enclosingSourceType();
277	} else {	278	} else {
278	if ((this.type.bits & ASTNode.IsDiamond) == 0) {	279	receiverType = this.type.resolveType(scope, true /* check bounds*/);
279	receiverType = this.type.resolveType(scope, true /* check bounds*/);	280	checkParameterizedAllocation: {
280	} else {	281	if (receiverType == null \|\| !receiverType.isValidBinding()) break checkParameterizedAllocation;
281	// can be done only after type arguments and method arguments resolution	282	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
		283	ReferenceBinding currentType = (ReferenceBinding)receiverType;
		284	do {
		285	// isStatic() is answering true for toplevel types
		286	if ((currentType.modifiers & ClassFileConstants.AccStatic) != 0) break checkParameterizedAllocation;
		287	if (currentType.isRawType()) break checkParameterizedAllocation;
		288	} while ((currentType = currentType.enclosingType())!= null);
		289	ParameterizedQualifiedTypeReference qRef = (ParameterizedQualifiedTypeReference) this.type;
		290	for (int i = qRef.typeArguments.length - 2; i >= 0; i--) {
		291	if (qRef.typeArguments[i] != null) {
		292	scope.problemReporter().illegalQualifiedParameterizedTypeAllocation(this.type, receiverType);
		293	break;
		294	}
		295	}
		296	}
282	}	297	}
283	// check for parameterized allocation deferred to below.
284	}	298	}
285	}	299	}
		300	if (receiverType == null \|\| !receiverType.isValidBinding()) {
		301	hasError = true;
		302	}
286		303
287	// resolve type arguments (for generic constructor call)	304	// resolve type arguments (for generic constructor call)
288	if (this.typeArguments != null) {	305	if (this.typeArguments != null) {
Lines 324-354 Link Here
324	}	341	}
325	}	342	}
326	}	343	}
327	if (this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
328	// Perform diamond inference here. (Not done yet.)
329	receiverType = this.type.resolveType(scope, true /* check bounds*/); // for now just do what we do for 1.6-
330	}
331	checkParameterizedAllocation: {
332	if (receiverType == null \|\| !receiverType.isValidBinding()) break checkParameterizedAllocation;
333	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
334	ReferenceBinding currentType = (ReferenceBinding)receiverType;
335	do {
336	// isStatic() is answering true for toplevel types
337	if ((currentType.modifiers & ClassFileConstants.AccStatic) != 0) break checkParameterizedAllocation;
338	if (currentType.isRawType()) break checkParameterizedAllocation;
339	} while ((currentType = currentType.enclosingType())!= null);
340	ParameterizedQualifiedTypeReference qRef = (ParameterizedQualifiedTypeReference) this.type;
341	for (int i = qRef.typeArguments.length - 2; i >= 0; i--) {
342	if (qRef.typeArguments[i] != null) {
343	scope.problemReporter().illegalQualifiedParameterizedTypeAllocation(this.type, receiverType);
344	break;
345	}
346	}
347	}
348	}
349	if (receiverType == null \|\| !receiverType.isValidBinding()) {
350	hasError = true;
351	}
352		344
353	// limit of fault-tolerance	345	// limit of fault-tolerance
354	if (hasError) {	346	if (hasError) {
Lines 394-399 Link Here
394	scope.problemReporter().cannotInstantiate(this.type, receiverType);	386	scope.problemReporter().cannotInstantiate(this.type, receiverType);
395	return this.resolvedType = receiverType;	387	return this.resolvedType = receiverType;
396	}	388	}
		389	if (this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
		390	TypeBinding [] inferredTypes = inferElidedTypes(((ParameterizedTypeBinding) receiverType).genericType(), argumentTypes, scope);
		391	receiverType = this.type.resolvedType = scope.environment().createParameterizedType(((ParameterizedTypeBinding) receiverType).genericType(), inferredTypes, ((ParameterizedTypeBinding) receiverType).enclosingType());
		392	}
397	ReferenceBinding allocationType = (ReferenceBinding) receiverType;	393	ReferenceBinding allocationType = (ReferenceBinding) receiverType;
398	if ((this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {	394	if ((this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {
399	if (isMethodUseDeprecated(this.binding, scope, true)) {	395	if (isMethodUseDeprecated(this.binding, scope, true)) {

Lines 17-28 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-16 / +159 lines)
17	*******************************************************************************/	17	*******************************************************************************/
18	package org.eclipse.jdt.internal.compiler.ast;	18	package org.eclipse.jdt.internal.compiler.ast;
19		19
		20	import org.eclipse.jdt.core.compiler.CharOperation;
20	import org.eclipse.jdt.internal.compiler.ASTVisitor;	21	import org.eclipse.jdt.internal.compiler.ASTVisitor;
21	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	22	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
22	import org.eclipse.jdt.internal.compiler.codegen.*;	23	import org.eclipse.jdt.internal.compiler.codegen.*;
23	import org.eclipse.jdt.internal.compiler.flow.*;	24	import org.eclipse.jdt.internal.compiler.flow.*;
24	import org.eclipse.jdt.internal.compiler.impl.Constant;	25	import org.eclipse.jdt.internal.compiler.impl.Constant;
25	import org.eclipse.jdt.internal.compiler.lookup.*;	26	import org.eclipse.jdt.internal.compiler.lookup.*;
		27	import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
26		28
27	public class AllocationExpression extends Expression implements InvocationSite {	29	public class AllocationExpression extends Expression implements InvocationSite {
28		30
Lines 260-270 Link Here
260	// initialization of an enum constant	262	// initialization of an enum constant
261	this.resolvedType = scope.enclosingReceiverType();	263	this.resolvedType = scope.enclosingReceiverType();
262	} else {	264	} else {
263	if ((this.type.bits & ASTNode.IsDiamond) != 0) {	265	this.resolvedType = this.type.resolveType(scope, true /* check bounds*/);
264	this.resolvedType = null; // can be done only after type arguments and method arguments resolution.
265	} else {
266	this.resolvedType = this.type.resolveType(scope, true /* check bounds*/);
267	}
268	// check for parameterized allocation deferred to below.	266	// check for parameterized allocation deferred to below.
269	}	267	}
270	// will check for null after args are resolved	268	// will check for null after args are resolved
Lines 338-346 Link Here
338	return this.resolvedType;	336	return this.resolvedType;
339	}	337	}
340	}	338	}
341	if (this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0) {	339	if (this.resolvedType == null \|\| !this.resolvedType.isValidBinding()) {
342	// Perform diamond inference here. (Not done yet.)	340	return null;
343	this.resolvedType = this.type.resolveType(scope, true /* check bounds*/); // for now just do what we do for 1.6-	341	}
		342
		343	// null type denotes fake allocation for enum constant inits
		344	if (this.type != null && !this.resolvedType.canBeInstantiated()) {
		345	scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
		346	return this.resolvedType;
		347	}
		348	if (this.type != null && this.resolvedType != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
		349	TypeBinding [] inferredTypes = inferElidedTypes(((ParameterizedTypeBinding) this.resolvedType).genericType(), argumentTypes, scope);
		350	this.resolvedType = this.type.resolvedType = scope.environment().createParameterizedType(((ParameterizedTypeBinding) this.resolvedType).genericType(), inferredTypes, ((ParameterizedTypeBinding) this.resolvedType).enclosingType());
		351	// inject inferred args ??
344	}	352	}
345	checkParameterizedAllocation: {	353	checkParameterizedAllocation: {
346	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()	354	if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
Lines 360-374 Link Here
360	}	368	}
361	}	369	}
362	}	370	}
363	if (this.resolvedType == null \|\| !this.resolvedType.isValidBinding()) {
364	return null;
365	}
366		371
367	// null type denotes fake allocation for enum constant inits
368	if (this.type != null && !this.resolvedType.canBeInstantiated()) {
369	scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
370	return this.resolvedType;
371	}
372	ReferenceBinding allocationType = (ReferenceBinding) this.resolvedType;	372	ReferenceBinding allocationType = (ReferenceBinding) this.resolvedType;
373	if (!(this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {	373	if (!(this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {
374	if (this.binding.declaringClass == null) {	374	if (this.binding.declaringClass == null) {
Lines 394-399 Link Here
394	return allocationType;	394	return allocationType;
395	}	395	}
396		396
		397	public TypeBinding[] inferElidedTypes(ReferenceBinding allocationType, TypeBinding[] argumentTypes, final BlockScope scope) {
		398	MethodBinding factory = getStaticFactory(allocationType, argumentTypes, scope);
		399	if (factory instanceof ParameterizedGenericMethodBinding) {
		400	return ((ParameterizedTypeBinding)factory.returnType).arguments;
		401	}
		402	int arity = allocationType.typeVariables().length;
		403	TypeBinding [] inferredTypes = new TypeBinding[arity];
		404	for (int i = 0; i < arity; i++) {
		405	inferredTypes[i] = new ProblemReferenceBinding(CharOperation.NO_CHAR_CHAR, null, ProblemReasons.InferenceFailed);
		406	}
		407	return inferredTypes;
		408	}
		409
		410	private MethodBinding getStaticFactory (ReferenceBinding allocationType, TypeBinding[] argumentTypes, final BlockScope scope) {
		411	TypeVariableBinding[] classTypeVariables = allocationType.typeVariables();
		412	int classTypeVariablesArity = classTypeVariables.length;
		413	MethodBinding[] methods = allocationType.getMethods(TypeConstants.INIT, argumentTypes.length);
		414	MethodBinding [] staticFactories = new MethodBinding[methods.length];
		415	int sfi = 0;
		416	for (int i = 0, length = methods.length; i < length; i++) {
		417	MethodBinding method = methods[i];
		418
		419	TypeVariableBinding[] methodTypeVariables = method.typeVariables();
		420	int methodTypeVariablesArity = methodTypeVariables.length;
		421
		422	if (this.genericTypeArguments != null && this.genericTypeArguments.length < methodTypeVariablesArity)
		423	continue; // wrong tree, don't bark.
		424	MethodBinding staticFactory = new MethodBinding(method.modifiers \| ClassFileConstants.AccStatic, TypeConstants.SYNTHETIC_STATIC_FACTORY,
		425	null, null, null, method.declaringClass);
		426	staticFactory.typeVariables = new TypeVariableBinding[classTypeVariablesArity + (this.genericTypeArguments == null ? methodTypeVariablesArity : 0)];
		427	final SimpleLookupTable map = new SimpleLookupTable(classTypeVariablesArity + methodTypeVariablesArity);
		428	// Rename each type variable T of the type to T'
		429	for (int j = 0; j < classTypeVariablesArity; j++) {
		430	map.put(classTypeVariables[j], staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(classTypeVariables[j].sourceName, "'".toCharArray()), //$NON-NLS-1$
		431	staticFactory, j, scope.environment()));
		432	}
		433	// Rename each type variable U of method U to U'' if not explicitly parameterized. Otherwise use the parameterizing type.
		434	for (int j = classTypeVariablesArity, max = classTypeVariablesArity + methodTypeVariablesArity; j < max; j++) {
		435	map.put(methodTypeVariables[j - classTypeVariablesArity],
		436	this.genericTypeArguments != null ? this.genericTypeArguments[j - classTypeVariablesArity] :
		437	(staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(methodTypeVariables[j - classTypeVariablesArity].sourceName, "''".toCharArray()), //$NON-NLS-1$
		438	staticFactory, j, scope.environment())));
		439	}
		440
		441	Substitution substitution = new Substitution() {
		442	public LookupEnvironment environment() {
		443	return scope.environment();
		444	}
		445	public boolean isRawSubstitution() {
		446	return false;
		447	}
		448	public TypeBinding substitute(TypeVariableBinding typeVariable) {
		449	return (TypeBinding) map.get(typeVariable);
		450	}
		451	};
		452
		453	staticFactory.parameters = Scope.substitute(substitution, method.parameters);
		454
		455	// initialize new variable bounds
		456	for (int j = 0, max = classTypeVariablesArity + methodTypeVariablesArity; j < max; j++) {
		457	TypeVariableBinding originalVariable = j < classTypeVariablesArity ? classTypeVariables[j] : methodTypeVariables[j - classTypeVariablesArity];
		458	TypeBinding substitutedType = (TypeBinding) map.get(originalVariable);
		459	if (substitutedType instanceof TypeVariableBinding) {
		460	TypeVariableBinding substitutedVariable = (TypeVariableBinding) substitutedType;
461	TypeBinding substitutedSuperclass = Scope.substitute(substitution, originalVariable.superclass);
462	ReferenceBinding[] substitutedInterfaces = Scope.substitute(substitution, originalVariable.superInterfaces);
463	if (originalVariable.firstBound != null) {
464	substitutedVariable.firstBound = originalVariable.firstBound == originalVariable.superclass
465	? substitutedSuperclass // could be array type or interface
466	: substitutedInterfaces[0];
467	}
468	switch (substitutedSuperclass.kind()) {
469	case Binding.ARRAY_TYPE :
470	substitutedVariable.superclass = scope.environment().getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
471	substitutedVariable.superInterfaces = substitutedInterfaces;
472	break;
473	default:
474	if (substitutedSuperclass.isInterface()) {
475	substitutedVariable.superclass = scope.environment().getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
476	int interfaceCount = substitutedInterfaces.length;
477	System.arraycopy(substitutedInterfaces, 0, substitutedInterfaces = new ReferenceBinding[interfaceCount+1], 1, interfaceCount);
478	substitutedInterfaces[0] = (ReferenceBinding) substitutedSuperclass;
479	substitutedVariable.superInterfaces = substitutedInterfaces;
480	} else {
481	substitutedVariable.superclass = (ReferenceBinding) substitutedSuperclass; // typeVar was extending other typeVar which got substituted with interface
482	substitutedVariable.superInterfaces = substitutedInterfaces;
483	}
484	}
485	}
486	}
487	TypeVariableBinding[] returnTypeParameters = new TypeVariableBinding[classTypeVariablesArity];
488	for (int j = 0; j < classTypeVariablesArity; j++) {
489	returnTypeParameters[j] = (TypeVariableBinding) map.get(classTypeVariables[j]);
490	}
491	staticFactory.returnType = scope.environment().createParameterizedType(allocationType, returnTypeParameters, allocationType.enclosingType());
492	staticFactory.thrownExceptions = Scope.substitute(substitution, method.thrownExceptions);
493	if (staticFactory.thrownExceptions == null) {
494	staticFactory.thrownExceptions = Binding.NO_EXCEPTIONS;
495	}
496	staticFactories[sfi++] = new ParameterizedMethodBinding((ParameterizedTypeBinding) scope.environment().convertToParameterizedType(staticFactory.declaringClass),
497	staticFactory);
498	}
499	if (sfi != methods.length) {
500	System.arraycopy(staticFactories, 0, staticFactories = new MethodBinding[sfi], 0, sfi);
501	}
502	final InvocationSite allocationSite = this;
503	InvocationSite site = new InvocationSite() { // Alternate site to not expose the generic type arguments as they have already been substituted.
504	public int sourceStart() { return allocationSite.sourceStart(); }
505	public int sourceEnd() { return allocationSite.sourceEnd(); }
506	public void setFieldIndex(int depth) { allocationSite.setFieldIndex(depth); }
507	public void setDepth(int depth) { allocationSite.setDepth(depth);}
508	public void setActualReceiverType(ReferenceBinding receiverType) { allocationSite.setActualReceiverType(receiverType);}
509	public boolean isTypeAccess() { return allocationSite.isTypeAccess(); }
510	public boolean isSuperAccess() { return allocationSite.isSuperAccess(); }
511	public TypeBinding[] genericTypeArguments() { return null; }
512	public TypeBinding expectedType() { return allocationSite.expectedType(); }
513	};
514	MethodBinding[] compatible = new MethodBinding[sfi];
515	int compatibleIndex = 0;
516	for (int i = 0; i < sfi; i++) {
517	MethodBinding compatibleMethod = scope.computeCompatibleMethod(staticFactories[i], argumentTypes, site);
518	if (compatibleMethod != null) {
519	if (compatibleMethod.isValidBinding())
520	compatible[compatibleIndex++] = compatibleMethod;
521	}
522	}
523
524	if (compatibleIndex == 0) {
525	return null;
526	}
527	MethodBinding[] visible = new MethodBinding[compatibleIndex];
528	int visibleIndex = 0;
529	for (int i = 0; i < compatibleIndex; i++) {
530	MethodBinding method = compatible[i];
531	if (method.canBeSeenBy(this, scope))
532	visible[visibleIndex++] = method;
533	}
534	if (visibleIndex == 0) {
535	return null;
536	}
537	return visibleIndex == 1 ? visible[0] : scope.mostSpecificMethodBinding(visible, visibleIndex, argumentTypes, this, allocationType);
538	}
539
397	public void setActualReceiverType(ReferenceBinding receiverType) {	540	public void setActualReceiverType(ReferenceBinding receiverType) {
398	// ignored	541	// ignored
399	}	542	}

Lines 18-24 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest_1_7.java (-43 / +205 lines)
18	public class GenericsRegressionTest_1_7 extends AbstractRegressionTest {	18	public class GenericsRegressionTest_1_7 extends AbstractRegressionTest {
19		19
20	static {	20	static {
21	// TESTS_NAMES = new String[] { "test0014" };	21	// TESTS_NAMES = new String[] { "test0025" };
22	// TESTS_NUMBERS = new int[] { 40, 41, 43, 45, 63, 64 };	22	// TESTS_NUMBERS = new int[] { 40, 41, 43, 45, 63, 64 };
23	// TESTS_RANGE = new int[] { 11, -1 };	23	// TESTS_RANGE = new int[] { 11, -1 };
24	}	24	}
Lines 28-34 Link Here
28	public static Test suite() {	28	public static Test suite() {
29	return buildMinimalComplianceTestSuite(testClass(), F_1_7);	29	return buildMinimalComplianceTestSuite(testClass(), F_1_7);
30	}	30	}
31	public void _test001() {	31	public void test001() {
32	this.runConformTest(	32	this.runConformTest(
33	new String[] {	33	new String[] {
34	"X.java",	34	"X.java",
Lines 44-50 Link Here
44	},	44	},
45	"SUCCESS");	45	"SUCCESS");
46	}	46	}
47	public void _test001a() {	47	public void test001a() {
48	this.runNegativeTest(	48	this.runNegativeTest(
49	new String[] {	49	new String[] {
50	"X.java",	50	"X.java",
Lines 65-71 Link Here
65	"The method testFunction(String) in the type X<String> is not applicable for the arguments (int)\n" +	65	"The method testFunction(String) in the type X<String> is not applicable for the arguments (int)\n" +
66	"----------\n");	66	"----------\n");
67	}	67	}
68	public void _test001b() {	68	public void test001b() {
69	this.runConformTest(	69	this.runConformTest(
70	new String[] {	70	new String[] {
71	"X.java",	71	"X.java",
Lines 80-86 Link Here
80	"SUCCESS");	80	"SUCCESS");
81	}	81	}
82	// fields	82	// fields
83	public void _test001b_1() {	83	public void test001b_1() {
84	this.runConformTest(	84	this.runConformTest(
85	new String[] {	85	new String[] {
86	"X.java",	86	"X.java",
Lines 94-100 Link Here
94	},	94	},
95	"SUCCESS");	95	"SUCCESS");
96	}	96	}
97	public void _test001c() {	97	public void test001c() {
98	this.runNegativeTest(	98	this.runNegativeTest(
99	new String[] {	99	new String[] {
100	"X.java",	100	"X.java",
Lines 114-120 Link Here
114	"----------\n");	114	"----------\n");
115	}	115	}
116	// fields	116	// fields
117	public void _test001c_1() {	117	public void test001c_1() {
118	this.runNegativeTest(	118	this.runNegativeTest(
119	new String[] {	119	new String[] {
120	"X.java",	120	"X.java",
Lines 133-139 Link Here
133	"The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)\n" +	133	"The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)\n" +
134	"----------\n");	134	"----------\n");
135	}	135	}
136	public void _test001d() {	136	public void test001d() {
137	this.runNegativeTest(	137	this.runNegativeTest(
138	new String[] {	138	new String[] {
139	"X.java",	139	"X.java",
Lines 155-161 Link Here
155	"The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Object>)\n" +	155	"The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Object>)\n" +
156	"----------\n");	156	"----------\n");
157	}	157	}
158	public void _test001e() {	158	public void test001e() {
159	this.runNegativeTest(	159	this.runNegativeTest(
160	new String[] {	160	new String[] {
161	"X.java",	161	"X.java",
Lines 177-184 Link Here
177	"The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Object>)\n" +	177	"The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Object>)\n" +
178	"----------\n");	178	"----------\n");
179	}	179	}
180	public void _test001f() {	180	public void test001f() {
181	this.runConformTest(	181	this.runNegativeTest(
182	new String[] {	182	new String[] {
183	"X.java",	183	"X.java",
184	"public class X<T> {\n" +	184	"public class X<T> {\n" +
Lines 193-199 Link Here
193	" }\n" +	193	" }\n" +
194	"}",	194	"}",
195	},	195	},
196	"SUCCESS");	196	"----------\n" +
		197	"1. WARNING in X.java (at line 2)\n" +
		198	" class X2<T>{\n" +
		199	" ^\n" +
		200	"The type parameter T is hiding the type T\n" +
		201	"----------\n" +
		202	"2. ERROR in X.java (at line 8)\n" +
		203	" X<String>.X2<String> x = new X<>().new X2<>();\n" +
		204	" ^^^^^^^^^^^^^^^^^^^^\n" +
		205	"Type mismatch: cannot convert from X<Object>.X2<String> to X<String>.X2<String>\n" +
		206	"----------\n");
197	}	207	}
198	// fields	208	// fields
199	public void test001f_1() {	209	public void test001f_1() {
Lines 216-223 Link Here
216	},	226	},
217	"SUCCESS");	227	"SUCCESS");
218	}	228	}
219	public void _test001g() {	229	public void test001g() {
220	this.runConformTest(	230	this.runNegativeTest(
221	new String[] {	231	new String[] {
222	"X.java",	232	"X.java",
223	"public class X<T> {\n" +	233	"public class X<T> {\n" +
Lines 233-239 Link Here
233	" }\n" +	243	" }\n" +
234	"}",	244	"}",
235	},	245	},
236	"SUCCESS\n1");	246	"----------\n" +
		247	"1. ERROR in X.java (at line 9)\n" +
		248	" X<String>.X2<Integer> x = new X<>().new X2<>();\n" +
		249	" ^^^^^^^^^^^^^^^^^^^^\n" +
		250	"Type mismatch: cannot convert from X<Object>.X2<Integer> to X<String>.X2<Integer>\n" +
		251	"----------\n");
237	}	252	}
238	public void test001g_1() {	253	public void test001g_1() {
239	this.runConformTest(	254	this.runConformTest(
Lines 256-262 Link Here
256	},	271	},
257	"SUCCESS\n1");	272	"SUCCESS\n1");
258	}	273	}
259	public void _test001h() {	274	public void test001h() {
260	this.runNegativeTest(	275	this.runNegativeTest(
261	new String[] {	276	new String[] {
262	"X.java",	277	"X.java",
Lines 278-290 Link Here
278	" ^\n" +	293	" ^\n" +
279	"The type parameter T is hiding the type T\n" +	294	"The type parameter T is hiding the type T\n" +
280	"----------\n" +	295	"----------\n" +
281	"2. ERROR in X.java (at line 9)\n" +	296	"2. ERROR in X.java (at line 8)\n" +
		297	" X<String>.X2<String> x = new X<>().new X2<>();\n" +
		298	" ^^^^^^^^^^^^^^^^^^^^\n" +
		299	"Type mismatch: cannot convert from X<Object>.X2<String> to X<String>.X2<String>\n" +
		300	"----------\n" +
		301	"3. ERROR in X.java (at line 9)\n" +
282	" x.methodx(1);\n" +	302	" x.methodx(1);\n" +
283	" ^^^^^^^\n" +	303	" ^^^^^^^\n" +
284	"The method methodx(String) in the type X<String>.X2<String> is not applicable for the arguments (int)\n" +	304	"The method methodx(String) in the type X<String>.X2<String> is not applicable for the arguments (int)\n" +
285	"----------\n");	305	"----------\n");
286	}	306	}
287	public void _test001h_1() {	307	public void test001h_1() {
288	this.runNegativeTest(	308	this.runNegativeTest(
289	new String[] {	309	new String[] {
290	"X.java",	310	"X.java",
Lines 329-339 Link Here
329	"Type safety: The method methodx(Object) belongs to the raw type X.X2. References to generic type X<T>.X2<T> should be parameterized\n" +	349	"Type safety: The method methodx(Object) belongs to the raw type X.X2. References to generic type X<T>.X2<T> should be parameterized\n" +
330	"----------\n");	350	"----------\n");
331	}	351	}
332	public void _test001i() {	352	public void test001h_2() {
333	this.runConformTest(	353	this.runConformTest(
334	new String[] {	354	new String[] {
335	"X.java",	355	"X.java",
336	"public class X<T> {\n" +	356	"public class X<T> {\n" +
		357	" class X2<T>{\n" +
		358	" void methodx(T param){\n" +
		359	" System.out.println(param);\n" +
		360	" }\n" +
		361	" }\n" +
		362	" X<String>.X2<String> x;\n" +
		363	" public static void main(String[] args) {\n" +
		364	" X test = new X();\n" +
		365	" test.x = new X<>().new X2<>();\n" +
		366	" test.x.methodx(1);\n" +
		367	" }\n" +
		368	"}",
		369	},
		370	"1");
		371	}
		372	public void test001i() {
		373	this.runNegativeTest(
		374	new String[] {
		375	"X.java",
		376	"public class X<T> {\n" +
337	" class X2<K>{\n" +	377	" class X2<K>{\n" +
338	" class X22<I>{\n" +	378	" class X22<I>{\n" +
339	" void methodx(T param, K param2, I param3){\n" +	379	" void methodx(T param, K param2, I param3){\n" +
Lines 348-354 Link Here
348	" }\n" +	388	" }\n" +
349	"}",	389	"}",
350	},	390	},
351	"SUCCESS");	391	"----------\n" +
		392	"1. ERROR in X.java (at line 10)\n" +
		393	" X<String> test = new X<>(); X<String>.X2<Integer>.X22<X<String>> x = new X<>().new X2<>().new X22<>();\n" +
		394	" ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		395	"Type mismatch: cannot convert from X<Object>.X2<Object>.X22<X<String>> to X<String>.X2<Integer>.X22<X<String>>\n" +
		396	"----------\n");
352	}	397	}
353	public void test002() {	398	public void test002() {
354	this.runNegativeTest(	399	this.runNegativeTest(
Lines 376-382 Link Here
376	"Type safety: The method testFunction(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" +	421	"Type safety: The method testFunction(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" +
377	"----------\n");	422	"----------\n");
378	}	423	}
379	public void _test003() {	424	public void test003() {
380	this.runConformTest(	425	this.runConformTest(
381	new String[] {	426	new String[] {
382	"X.java",	427	"X.java",
Lines 392-398 Link Here
392	"SUCCESS");	437	"SUCCESS");
393	}	438	}
394		439
395	public void _test004b() {	440	public void test004b() {
396	this.runNegativeTest(	441	this.runNegativeTest(
397	new String[] {	442	new String[] {
398	"X.java",	443	"X.java",
Lines 437-443 Link Here
437	"1");	482	"1");
438	}	483	}
439		484
440	public void _test006() {	485	public void test006() {
441	this.runConformTest(	486	this.runConformTest(
442	new String[] {	487	new String[] {
443	"X.java",	488	"X.java",
Lines 460-466 Link Here
460	"SUCCESS");	505	"SUCCESS");
461	}	506	}
462	// shows the difference between using <> and the raw type - different semantics	507	// shows the difference between using <> and the raw type - different semantics
463	public void _test007() {	508	public void test007() {
464	this.runConformTest(	509	this.runConformTest(
465	new String[] {	510	new String[] {
466	"X.java",	511	"X.java",
Lines 487-493 Link Here
487	"1\n" +	532	"1\n" +
488	"2");	533	"2");
489	}	534	}
490	public void _test007a() {	535	public void test007a() {
491	this.runNegativeTest(	536	this.runNegativeTest(
492	new String[] {	537	new String[] {
493	"X.java",	538	"X.java",
Lines 529-540 Link Here
529	"----------\n");	574	"----------\n");
530	}	575	}
531	//shows the difference between using <> and the raw type - different semantics	576	//shows the difference between using <> and the raw type - different semantics
532	public void _test008() {	577	public void test008() {
533	this.runConformTest(	578	this.runNegativeTest(
534	new String[] {	579	new String[] {
535	"X.java",	580	"X.java",
536	"public class X<T> {\n" +	581	"public class X<T> {\n" +
537	" T field1;" +	582	" T field1;\n" +
538	" public X(T param){\n" +	583	" public X(T param){\n" +
539	" field1 = param;\n" +	584	" field1 = param;\n" +
540	" }\n" +	585	" }\n" +
Lines 547-556 Link Here
547	" }\n" +	592	" }\n" +
548	"}",	593	"}",
549	},	594	},
550	"");	595	"----------\n" +
		596	"1. WARNING in X.java (at line 7)\n" +
		597	" X<?> x1 = new X(1).get(\"\");\n" +
		598	" ^^^^^^^^\n" +
		599	"Type safety: The constructor X(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" +
		600	"----------\n" +
		601	"2. WARNING in X.java (at line 7)\n" +
		602	" X<?> x1 = new X(1).get(\"\");\n" +
		603	" ^^^^^^^^^^^^^^^^\n" +
		604	"Type safety: The method get(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" +
		605	"----------\n" +
		606	"3. WARNING in X.java (at line 7)\n" +
		607	" X<?> x1 = new X(1).get(\"\");\n" +
		608	" ^\n" +
		609	"X is a raw type. References to generic type X<T> should be parameterized\n" +
		610	"----------\n" +
		611	"4. ERROR in X.java (at line 8)\n" +
		612	" X<?> x2 = new X<>(1).get(\"\");\n" +
		613	" ^^^\n" +
		614	"The method get(Integer) in the type X<Integer> is not applicable for the arguments (String)\n" +
		615	"----------\n");
551	}	616	}
552		617
553	public void _test0014() {	618	public void test0014() {
554	this.runConformTest(	619	this.runConformTest(
555	new String[] {	620	new String[] {
556	"X.java",	621	"X.java",
Lines 568-574 Link Here
568	"SUCCESS\n" +	633	"SUCCESS\n" +
569	"123");	634	"123");
570	}	635	}
571	public void _test0014a() {	636	public void test0014a() {
572	this.runNegativeTest(	637	this.runNegativeTest(
573	new String[] {	638	new String[] {
574	"X.java",	639	"X.java",
Lines 590-596 Link Here
590	"The method testFunction(String, Integer) in the type X<String,Integer> is not applicable for the arguments (int, String)\n" +	655	"The method testFunction(String, Integer) in the type X<String,Integer> is not applicable for the arguments (int, String)\n" +
591	"----------\n");	656	"----------\n");
592	}	657	}
593	public void _test0015() {	658	public void test0015() {
594	this.runConformTest(	659	this.runConformTest(
595	new String[] {	660	new String[] {
596	"X.java",	661	"X.java",
Lines 611-618 Link Here
611	}	676	}
612	// To verify that a parameterized invocation of a generic constructor works even if <> is used	677	// To verify that a parameterized invocation of a generic constructor works even if <> is used
613	// to elide class type parameters.	678	// to elide class type parameters.
614	public void _test0016() {	679	public void test0016() {
615	this.runConformTest(	680	this.runConformTest( // javac fails to compile this, looks buggy
616	new String[] {	681	new String[] {
617	"X.java",	682	"X.java",
618	"public class X<T> {\n" +	683	"public class X<T> {\n" +
Lines 632-639 Link Here
632	}	697	}
633	// To verify that a parameterized invocation of a generic constructor works even if <> is used	698	// To verify that a parameterized invocation of a generic constructor works even if <> is used
634	// to elide class type parameters. This test handles fields	699	// to elide class type parameters. This test handles fields
635	public void _test0016b() {	700	public void test0016b() {
636	this.runConformTest(	701	this.runConformTest( // javac fails to compile this, looks buggy
637	new String[] {	702	new String[] {
638	"X.java",	703	"X.java",
639	"public class X<T> {\n" +	704	"public class X<T> {\n" +
Lines 657-664 Link Here
657	// To verify that a parameterized invocation of a non-generic constructor works even if <> is used	722	// To verify that a parameterized invocation of a non-generic constructor works even if <> is used
658	// to elide class type parameters.	723	// to elide class type parameters.
659	// This was not allowed in java 1.6 and 1.5 (https://bugs.eclipse.org/bugs/show_bug.cgi?id=168230)	724	// This was not allowed in java 1.6 and 1.5 (https://bugs.eclipse.org/bugs/show_bug.cgi?id=168230)
660	public void _test0017() {	725	public void test0017() {
661	this.runConformTest(	726	this.runConformTest( // javac fails to compile this, looks buggy
662	new String[] {	727	new String[] {
663	"X.java",	728	"X.java",
664	"public class X<T> {\n" +	729	"public class X<T> {\n" +
Lines 679-685 Link Here
679	"const.1\nconst.1\nconst.2");	744	"const.1\nconst.1\nconst.2");
680	}	745	}
681	// To verify that the correct constructor is found by parameter substitution in the diamond case	746	// To verify that the correct constructor is found by parameter substitution in the diamond case
682	public void _test0018() {	747	public void test0018() {
683	this.runConformTest(	748	this.runConformTest(
684	new String[] {	749	new String[] {
685	"X.java",	750	"X.java",
Lines 700-706 Link Here
700	}	765	}
701	// To verify that the correct constructor is found by parameter substitution	766	// To verify that the correct constructor is found by parameter substitution
702	// in the diamond case -- fields	767	// in the diamond case -- fields
703	public void _test0018b() {	768	public void test0018b() {
704	this.runConformTest(	769	this.runConformTest(
705	new String[] {	770	new String[] {
706	"X.java",	771	"X.java",
Lines 738-744 Link Here
738	"----------\n");	803	"----------\n");
739	}	804	}
740	// check inference at method argument position.	805	// check inference at method argument position.
741	public void _test0020() {	806	public void test0020() {
742	this.runNegativeTest(	807	this.runNegativeTest(
743	new String[] {	808	new String[] {
744	"X.java",	809	"X.java",
Lines 757-763 Link Here
757	"----------\n");	822	"----------\n");
758	}	823	}
759	//check inference at method argument position.	824	//check inference at method argument position.
760	public void _test0021() {	825	public void test0021() {
761	this.runNegativeTest(	826	this.runNegativeTest(
762	new String[] {	827	new String[] {
763	"X.java",	828	"X.java",
Lines 776-782 Link Here
776	"The method f(List<String>) in the type X<T> is not applicable for the arguments (ArrayList<Object>)\n" +	841	"The method f(List<String>) in the type X<T> is not applicable for the arguments (ArrayList<Object>)\n" +
777	"----------\n");	842	"----------\n");
778	}	843	}
779		844	public void test0022() {
		845	this.runConformTest(
		846	new String[] {
		847	"X.java",
		848	"import java.util.HashMap;\n" +
		849	"import java.util.Map;\n" +
		850	"\n" +
		851	"class StringKeyHashMap<V> extends HashMap<String, V> { \n" +
		852	"}\n" +
		853	"\n" +
		854	"class IntegerValueHashMap<K> extends HashMap<K, Integer> { \n" +
		855	"}\n" +
		856	"\n" +
		857	"public class X {\n" +
		858	" Map<String, Integer> m1 = new StringKeyHashMap<>();\n" +
		859	" Map<String, Integer> m2 = new IntegerValueHashMap<>();\n" +
		860	"}\n"
		861	},
		862	"");
		863	}
		864	public void test0023() {
		865	this.runNegativeTest(
		866	new String[] {
		867	"X.java",
		868	"import java.util.HashMap;\n" +
		869	"import java.util.Map;\n" +
		870	"\n" +
		871	"class StringKeyHashMap<V> extends HashMap<String, V> { \n" +
		872	"}\n" +
		873	"\n" +
		874	"class IntegerValueHashMap<K> extends HashMap<K, Integer> { \n" +
		875	"}\n" +
		876	"\n" +
		877	"public class X {\n" +
		878	" Map<String, Integer> m1 = new StringKeyHashMap<>(10);\n" +
		879	" Map<String, Integer> m2 = new IntegerValueHashMap<>();\n" +
		880	"}\n"
		881	},
		882	"----------\n" +
		883	"1. WARNING in X.java (at line 4)\n" +
		884	" class StringKeyHashMap<V> extends HashMap<String, V> { \n" +
		885	" ^^^^^^^^^^^^^^^^\n" +
		886	"The serializable class StringKeyHashMap does not declare a static final serialVersionUID field of type long\n" +
		887	"----------\n" +
		888	"2. WARNING in X.java (at line 7)\n" +
		889	" class IntegerValueHashMap<K> extends HashMap<K, Integer> { \n" +
		890	" ^^^^^^^^^^^^^^^^^^^\n" +
		891	"The serializable class IntegerValueHashMap does not declare a static final serialVersionUID field of type long\n" +
		892	"----------\n" +
		893	"3. ERROR in X.java (at line 11)\n" +
		894	" Map<String, Integer> m1 = new StringKeyHashMap<>(10);\n" +
		895	" ^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		896	"The constructor StringKeyHashMap<>(int) is undefined\n" +
		897	"----------\n" +
		898	"4. ERROR in X.java (at line 11)\n" +
		899	" Map<String, Integer> m1 = new StringKeyHashMap<>(10);\n" +
		900	" ^^^^^^^^^^^^^^^^^^^^^^^^^^\n" +
		901	"Type mismatch: cannot convert from StringKeyHashMap<> to Map<String,Integer>\n" +
		902	"----------\n");
		903	}
		904	// check inference at return expression.
		905	public void test0024() {
		906	this.runNegativeTest(
		907	new String[] {
		908	"X.java",
909	"import java.util.List;\n" +
910	"import java.util.ArrayList;\n" +
911	"class X<T> {\n" +
912	" public X() {}\n" +
913	" X<String> f(List<String> p) {return new X<>();}\n" +
914	"}\n",
915	},
916	"----------\n" +
917	"1. WARNING in X.java (at line 2)\n" +
918	" import java.util.ArrayList;\n" +
919	" ^^^^^^^^^^^^^^^^^^^\n" +
920	"The import java.util.ArrayList is never used\n" +
921	"----------\n");
922	}
923	// check inference at cast expression.
924	public void test0025() {
925	this.runNegativeTest(
926	new String[] {
927	"X.java",
928	"import java.util.List;\n" +
929	"import java.util.ArrayList;\n" +
930	"class X<T> {\n" +
931	" public X() {}\n" +
932	" void f(List<String> p) { Object o = (X<String>) new X<>();}\n" +
933	"}\n",
934	},
935	"----------\n" +
936	"1. ERROR in X.java (at line 5)\n" +
937	" void f(List<String> p) { Object o = (X<String>) new X<>();}\n" +
938	" ^^^^^^^^^^^^^^^^^^^^^\n" +
939	"Cannot cast from X<Object> to X<String>\n" +
940	"----------\n");
941	}
780	public static Class testClass() {	942	public static Class testClass() {
781	return GenericsRegressionTest_1_7.class;	943	return GenericsRegressionTest_1_7.class;
782	}	944	}