Attachment #193951 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 {


	public TypeReference[] typeArguments;
	public TypeBinding[] genericTypeArguments;
	public FieldDeclaration enumConstant; // for enum constant initializations
	private TypeBinding expectedTypeForInference;	  // for <> inference

public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
	// check captured variables are initialized in current context (26134)

		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());
		// TODO(Srikanth) : inject inferred arguments ??
 	}
	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
}

	}
	visitor.endVisit(this, scope);
}
/**
 * @see org.eclipse.jdt.internal.compiler.ast.Expression#setExpectedType(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
 */
public void setExpectedType(TypeBinding expectedType) {
	this.expectedTypeForInference = expectedType;
}
/**
 * @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#expectedType()
 */
public TypeBinding expectedType() {
	return this.expectedTypeForInference;
}

}

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);

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 17-28 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (+164 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 33-38 Link Here
33	public TypeReference[] typeArguments;	35	public TypeReference[] typeArguments;
34	public TypeBinding[] genericTypeArguments;	36	public TypeBinding[] genericTypeArguments;
35	public FieldDeclaration enumConstant; // for enum constant initializations	37	public FieldDeclaration enumConstant; // for enum constant initializations
		38	private TypeBinding expectedTypeForInference; // for <> inference
36		39
37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	40	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
38	// check captured variables are initialized in current context (26134)	41	// check captured variables are initialized in current context (26134)
Lines 359-364 Link Here
359	scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);	362	scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
360	return this.resolvedType;	363	return this.resolvedType;
361	}	364	}
		365	if (this.type != null && this.resolvedType != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
		366	TypeBinding [] inferredTypes = inferElidedTypes(((ParameterizedTypeBinding) this.resolvedType).genericType(), argumentTypes, scope);
		367	this.resolvedType = this.type.resolvedType = scope.environment().createParameterizedType(((ParameterizedTypeBinding) this.resolvedType).genericType(), inferredTypes, ((ParameterizedTypeBinding) this.resolvedType).enclosingType());
		368	// TODO(Srikanth) : inject inferred arguments ??
		369	}
362	ReferenceBinding allocationType = (ReferenceBinding) this.resolvedType;	370	ReferenceBinding allocationType = (ReferenceBinding) this.resolvedType;
363	if (!(this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {	371	if (!(this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {
364	if (this.binding.declaringClass == null) {	372	if (this.binding.declaringClass == null) {
Lines 384-389 Link Here
384	return allocationType;	392	return allocationType;
385	}	393	}
386		394
		395	public TypeBinding[] inferElidedTypes(ReferenceBinding allocationType, TypeBinding[] argumentTypes, final BlockScope scope) {
		396	MethodBinding factory = getStaticFactory(allocationType, argumentTypes, scope);
		397	if (factory instanceof ParameterizedGenericMethodBinding) {
		398	return ((ParameterizedTypeBinding)factory.returnType).arguments;
		399	}
		400	int arity = allocationType.typeVariables().length;
		401	TypeBinding [] inferredTypes = new TypeBinding[arity];
		402	for (int i = 0; i < arity; i++) {
		403	inferredTypes[i] = new ProblemReferenceBinding(CharOperation.NO_CHAR_CHAR, null, ProblemReasons.InferenceFailed);
		404	}
		405	return inferredTypes;
		406	}
		407
		408	private MethodBinding getStaticFactory (ReferenceBinding allocationType, TypeBinding[] argumentTypes, final BlockScope scope) {
		409	TypeVariableBinding[] classTypeVariables = allocationType.typeVariables();
		410	int classTypeVariablesArity = classTypeVariables.length;
		411	MethodBinding[] methods = allocationType.getMethods(TypeConstants.INIT, argumentTypes.length);
		412	MethodBinding [] staticFactories = new MethodBinding[methods.length];
		413	int sfi = 0;
		414	for (int i = 0, length = methods.length; i < length; i++) {
		415	MethodBinding method = methods[i];
		416
		417	TypeVariableBinding[] methodTypeVariables = method.typeVariables();
		418	int methodTypeVariablesArity = methodTypeVariables.length;
		419
		420	if (this.genericTypeArguments != null && this.genericTypeArguments.length < methodTypeVariablesArity)
		421	continue; // wrong tree, don't bark.
		422	MethodBinding staticFactory = new MethodBinding(method.modifiers \| ClassFileConstants.AccStatic, TypeConstants.SYNTHETIC_STATIC_FACTORY,
		423	null, null, null, method.declaringClass);
		424	staticFactory.typeVariables = new TypeVariableBinding[classTypeVariablesArity + (this.genericTypeArguments == null ? methodTypeVariablesArity : 0)];
		425	final SimpleLookupTable map = new SimpleLookupTable(classTypeVariablesArity + methodTypeVariablesArity);
		426	// Rename each type variable T of the type to T'
		427	for (int j = 0; j < classTypeVariablesArity; j++) {
		428	map.put(classTypeVariables[j], staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(classTypeVariables[j].sourceName, "'".toCharArray()), //$NON-NLS-1$
		429	staticFactory, j, scope.environment()));
		430	}
		431	// Rename each type variable U of method U to U'' if not explicitly parameterized. Otherwise use the parameterizing type.
		432	for (int j = classTypeVariablesArity, max = classTypeVariablesArity + methodTypeVariablesArity; j < max; j++) {
		433	map.put(methodTypeVariables[j - classTypeVariablesArity],
		434	this.genericTypeArguments != null ? this.genericTypeArguments[j - classTypeVariablesArity] :
		435	(staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(methodTypeVariables[j - classTypeVariablesArity].sourceName, "''".toCharArray()), //$NON-NLS-1$
		436	staticFactory, j, scope.environment())));
		437	}
		438
		439	Substitution substitution = new Substitution() {
		440	public LookupEnvironment environment() {
		441	return scope.environment();
		442	}
		443	public boolean isRawSubstitution() {
		444	return false;
		445	}
		446	public TypeBinding substitute(TypeVariableBinding typeVariable) {
		447	return (TypeBinding) map.get(typeVariable);
		448	}
		449	};
		450
		451	staticFactory.parameters = Scope.substitute(substitution, method.parameters);
		452
		453	// initialize new variable bounds
		454	for (int j = 0, max = classTypeVariablesArity + methodTypeVariablesArity; j < max; j++) {
		455	TypeVariableBinding originalVariable = j < classTypeVariablesArity ? classTypeVariables[j] : methodTypeVariables[j - classTypeVariablesArity];
		456	TypeBinding substitutedType = (TypeBinding) map.get(originalVariable);
		457	if (substitutedType instanceof TypeVariableBinding) {
		458	TypeVariableBinding substitutedVariable = (TypeVariableBinding) substitutedType;
459	TypeBinding substitutedSuperclass = Scope.substitute(substitution, originalVariable.superclass);
460	ReferenceBinding[] substitutedInterfaces = Scope.substitute(substitution, originalVariable.superInterfaces);
461	if (originalVariable.firstBound != null) {
462	substitutedVariable.firstBound = originalVariable.firstBound == originalVariable.superclass
463	? substitutedSuperclass // could be array type or interface
464	: substitutedInterfaces[0];
465	}
466	switch (substitutedSuperclass.kind()) {
467	case Binding.ARRAY_TYPE :
468	substitutedVariable.superclass = scope.environment().getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
469	substitutedVariable.superInterfaces = substitutedInterfaces;
470	break;
471	default:
472	if (substitutedSuperclass.isInterface()) {
473	substitutedVariable.superclass = scope.environment().getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
474	int interfaceCount = substitutedInterfaces.length;
475	System.arraycopy(substitutedInterfaces, 0, substitutedInterfaces = new ReferenceBinding[interfaceCount+1], 1, interfaceCount);
476	substitutedInterfaces[0] = (ReferenceBinding) substitutedSuperclass;
477	substitutedVariable.superInterfaces = substitutedInterfaces;
478	} else {
479	substitutedVariable.superclass = (ReferenceBinding) substitutedSuperclass; // typeVar was extending other typeVar which got substituted with interface
480	substitutedVariable.superInterfaces = substitutedInterfaces;
481	}
482	}
483	}
484	}
485	TypeVariableBinding[] returnTypeParameters = new TypeVariableBinding[classTypeVariablesArity];
486	for (int j = 0; j < classTypeVariablesArity; j++) {
487	returnTypeParameters[j] = (TypeVariableBinding) map.get(classTypeVariables[j]);
488	}
489	staticFactory.returnType = scope.environment().createParameterizedType(allocationType, returnTypeParameters, allocationType.enclosingType());
490	staticFactory.thrownExceptions = Scope.substitute(substitution, method.thrownExceptions);
491	if (staticFactory.thrownExceptions == null) {
492	staticFactory.thrownExceptions = Binding.NO_EXCEPTIONS;
493	}
494	staticFactories[sfi++] = new ParameterizedMethodBinding((ParameterizedTypeBinding) scope.environment().convertToParameterizedType(staticFactory.declaringClass),
495	staticFactory);
496	}
497	if (sfi != methods.length) {
498	System.arraycopy(staticFactories, 0, staticFactories = new MethodBinding[sfi], 0, sfi);
499	}
500	final InvocationSite allocationSite = this;
501	InvocationSite site = new InvocationSite() { // Alternate site to not expose the generic type arguments as they have already been substituted.
502	public int sourceStart() { return allocationSite.sourceStart(); }
503	public int sourceEnd() { return allocationSite.sourceEnd(); }
504	public void setFieldIndex(int depth) { allocationSite.setFieldIndex(depth); }
505	public void setDepth(int depth) { allocationSite.setDepth(depth);}
506	public void setActualReceiverType(ReferenceBinding receiverType) { allocationSite.setActualReceiverType(receiverType);}
507	public boolean isTypeAccess() { return allocationSite.isTypeAccess(); }
508	public boolean isSuperAccess() { return allocationSite.isSuperAccess(); }
509	public TypeBinding[] genericTypeArguments() { return null; }
510	public TypeBinding expectedType() { return allocationSite.expectedType(); }
511	};
512	MethodBinding[] compatible = new MethodBinding[sfi];
513	int compatibleIndex = 0;
514	for (int i = 0; i < sfi; i++) {
515	MethodBinding compatibleMethod = scope.computeCompatibleMethod(staticFactories[i], argumentTypes, site);
516	if (compatibleMethod != null) {
517	if (compatibleMethod.isValidBinding())
518	compatible[compatibleIndex++] = compatibleMethod;
519	}
520	}
521
522	if (compatibleIndex == 0) {
523	return null;
524	}
525	MethodBinding[] visible = new MethodBinding[compatibleIndex];
526	int visibleIndex = 0;
527	for (int i = 0; i < compatibleIndex; i++) {
528	MethodBinding method = compatible[i];
529	if (method.canBeSeenBy(this, scope))
530	visible[visibleIndex++] = method;
531	}
532	if (visibleIndex == 0) {
533	return null;
534	}
535	return visibleIndex == 1 ? visible[0] : scope.mostSpecificMethodBinding(visible, visibleIndex, argumentTypes, this, allocationType);
536	}
537
387	public void setActualReceiverType(ReferenceBinding receiverType) {	538	public void setActualReceiverType(ReferenceBinding receiverType) {
388	// ignored	539	// ignored
389	}	540	}
Lines 413-416 Link Here
413	}	564	}
414	visitor.endVisit(this, scope);	565	visitor.endVisit(this, scope);
415	}	566	}
		567	/**
		568	* @see org.eclipse.jdt.internal.compiler.ast.Expression#setExpectedType(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
		569	*/
		570	public void setExpectedType(TypeBinding expectedType) {
		571	this.expectedTypeForInference = expectedType;
		572	}
		573	/**
		574	* @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#expectedType()
		575	*/
		576	public TypeBinding expectedType() {
		577	return this.expectedTypeForInference;
		578	}
		579
416	}	580	}

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	}