Attachment #193962 for bug #339478

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

Lines 1379-1384 Link Here

(-)compiler/org/eclipse/jdt/core/compiler/IProblem.java (+2 lines)
1379	int PolymorphicMethodNotBelow17 = MethodRelated + 876;	1379	int PolymorphicMethodNotBelow17 = MethodRelated + 876;
1380	/** @since 3.7 */	1380	/** @since 3.7 */
1381	int IncorrectSwitchType17 = TypeRelated + 877;	1381	int IncorrectSwitchType17 = TypeRelated + 877;
		1382	/** @since 3.7 */
		1383	int CannotInferElidedTypes = TypeRelated + 878;
1382		1384
1383	/**	1385	/**
1384	* External problems -- These are problems defined by other plugins	1386	* External problems -- These are problems defined by other plugins

Lines 17-22 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (+38 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.*;
Lines 33-38 Link Here
33	public TypeReference[] typeArguments;	34	public TypeReference[] typeArguments;
34	public TypeBinding[] genericTypeArguments;	35	public TypeBinding[] genericTypeArguments;
35	public FieldDeclaration enumConstant; // for enum constant initializations	36	public FieldDeclaration enumConstant; // for enum constant initializations
		37	protected TypeBinding typeExpected; // for <> inference
36		38
37	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {	39	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
38	// check captured variables are initialized in current context (26134)	40	// check captured variables are initialized in current context (26134)
Lines 359-364 Link Here
359	scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);	361	scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
360	return this.resolvedType;	362	return this.resolvedType;
361	}	363	}
		364	if (this.type != null && (this.type.bits & ASTNode.IsDiamond) != 0) {
		365	TypeBinding [] inferredTypes = inferElidedTypes(((ParameterizedTypeBinding) this.resolvedType).genericType(), argumentTypes, scope);
		366	this.resolvedType = this.type.resolvedType = scope.environment().createParameterizedType(((ParameterizedTypeBinding) this.resolvedType).genericType(), inferredTypes, ((ParameterizedTypeBinding) this.resolvedType).enclosingType());
		367	}
362	ReferenceBinding allocationType = (ReferenceBinding) this.resolvedType;	368	ReferenceBinding allocationType = (ReferenceBinding) this.resolvedType;
363	if (!(this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {	369	if (!(this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {
364	if (this.binding.declaringClass == null) {	370	if (this.binding.declaringClass == null) {
Lines 384-389 Link Here
384	return allocationType;	390	return allocationType;
385	}	391	}
386		392
		393	public TypeBinding[] inferElidedTypes(ReferenceBinding allocationType, TypeBinding[] argumentTypes, final BlockScope scope) {
		394	/* Given the allocation type and the arguments to the constructor, see if we can synthesize a generic static factory
		395	method that would, given the argument types and the invocation site, manufacture a parameterized object of type allocationType.
		396	If we are successful then by design and construction, the parameterization of the return type of the factory method is identical
		397	to the types elided in the <>.
		398	*/
		399	MethodBinding factory = scope.getStaticFactory(allocationType, argumentTypes, this);
		400	if (factory instanceof ParameterizedGenericMethodBinding && factory.isValidBinding()) {
		401	return ((ParameterizedTypeBinding)factory.returnType).arguments;
		402	}
		403	scope.problemReporter().cannotInferElidedTypes(this);
		404	int arity = allocationType.typeVariables().length;
		405	TypeBinding [] inferredTypes = new TypeBinding[arity];
		406	for (int i = 0; i < arity; i++) {
		407	inferredTypes[i] = new ProblemReferenceBinding(CharOperation.NO_CHAR_CHAR, null, ProblemReasons.InferenceFailed);
		408	}
		409	return inferredTypes;
		410	}
		411
387	public void setActualReceiverType(ReferenceBinding receiverType) {	412	public void setActualReceiverType(ReferenceBinding receiverType) {
388	// ignored	413	// ignored
389	}	414	}
Lines 413-416 Link Here
413	}	438	}
414	visitor.endVisit(this, scope);	439	visitor.endVisit(this, scope);
415	}	440	}
		441	/**
		442	* @see org.eclipse.jdt.internal.compiler.ast.Expression#setExpectedType(org.eclipse.jdt.internal.compiler.lookup.TypeBinding)
		443	*/
		444	public void setExpectedType(TypeBinding expectedType) {
		445	this.typeExpected = expectedType;
		446	}
		447	/**
		448	* @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#expectedType()
		449	*/
		450	public TypeBinding expectedType() {
		451	return this.typeExpected;
		452	}
		453
416	}	454	}




						scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes, i);
						return null;
					}
					checkBounds = false; // successful <> inference needs no bounds check, we will scream foul if needed during inference.
				}
				// check parameterizing non-static member type of raw type
				if (typeIsConsistent && !currentType.isStatic()) {

					}
				}
				ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, qualifyingType);
				// check argument type compatibility for non <> cases - <> case needs no bounds check, we will scream foul if needed during inference.
				if (!isDiamond) {
					if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution
						parameterizedType.boundCheck(scope, args);
					else
						scope.deferBoundCheck(this);
				}
				qualifyingType = parameterizedType;
		    } else {
				ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();




				return null;
		}

		final boolean isDiamond = (this.bits & ASTNode.IsDiamond) != 0;
		TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();
		if (typeVariables == Binding.NO_TYPE_VARIABLES) { // non generic invoked with arguments
			boolean isCompliant15 = scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_5;

			}
			// if missing generic type, and compliance >= 1.5, then will rebuild a parameterized binding
		} else if (argLength != typeVariables.length) {
			if (!isDiamond) { // check arity, IsDiamond never set for 1.6-
				scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);
				return null;
			} 
			checkBounds = false; // successful <> inference needs no bounds check, we will scream foul if needed during inference.
		} else if (!currentType.isStatic()) {
			ReferenceBinding actualEnclosing = currentType.enclosingType();
			if (actualEnclosing != null && actualEnclosing.isRawType()){

		}

    	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, enclosingType);
		// check argument type compatibility for non <> cases - <> case needs no bounds check, we will scream foul if needed during inference.
    	if (!isDiamond) {
    		if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution
    			parameterizedType.boundCheck(scope, this.typeArguments);
    		else
    			scope.deferBoundCheck(this);
    	}
		if (isTypeUseDeprecated(parameterizedType, scope))
			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	}




import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;
import org.eclipse.jdt.internal.compiler.util.ObjectVector;
import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
import org.eclipse.jdt.internal.compiler.util.SimpleSet;

public abstract class Scope {

	int startIndex() {
		return 0;
	}
	/* Given an allocation type and arguments at the allocation site, answer a synthetic generic static factory method
	   that could instead be invoked with identical results. Return null if no compatible, visible, most specific method
	   could be found. This method is modeled after Scope.getConstructor and Scope.getMethod.
	 */
	public MethodBinding getStaticFactory (ReferenceBinding allocationType, TypeBinding[] argumentTypes, final InvocationSite allocationSite) {
		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;
	        
			final TypeBinding[] genericTypeArguments = allocationSite.genericTypeArguments();
			if (genericTypeArguments != null && 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 + (genericTypeArguments == null ? methodTypeVariablesArity : 0)];
			final SimpleLookupTable map = new SimpleLookupTable(classTypeVariablesArity + methodTypeVariablesArity);
			// Rename each type variable T of the type to T'
			final LookupEnvironment environment = environment();
			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, 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], 
						genericTypeArguments != null ? genericTypeArguments[j - classTypeVariablesArity] :
							(staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(methodTypeVariables[j - classTypeVariablesArity].sourceName, "''".toCharArray()), //$NON-NLS-1$
																			staticFactory, j, environment)));
			}
			final Scope scope = this;
			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);
					}
				};

			// 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 = environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
							substitutedVariable.superInterfaces = substitutedInterfaces;
							break;
						default:
							if (substitutedSuperclass.isInterface()) {
								substitutedVariable.superclass = 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 = environment.createParameterizedType(allocationType, returnTypeParameters, allocationType.enclosingType());
			staticFactory.parameters = Scope.substitute(substitution, method.parameters);
			staticFactory.thrownExceptions = Scope.substitute(substitution, method.thrownExceptions);
			if (staticFactory.thrownExceptions == null) { 
				staticFactory.thrownExceptions = Binding.NO_EXCEPTIONS;
			}
			staticFactories[sfi++] = new ParameterizedMethodBinding((ParameterizedTypeBinding) environment.convertToParameterizedType(staticFactory.declaringClass),
																												staticFactory);
		}
		if (sfi != methods.length) {
			System.arraycopy(staticFactories, 0, staticFactories = new MethodBinding[sfi], 0, sfi);
		}
		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 = 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(allocationSite, this))
				visible[visibleIndex++] = method;
		}
		if (visibleIndex == 0) {
			return null;
		}
		return visibleIndex == 1 ? visible[0] : mostSpecificMethodBinding(visible, visibleIndex, argumentTypes, allocationSite, allocationType);
	}
}

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$

Lines 7748-7751 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java (+8 lines)
7748	resources[0].declarationSourceStart,	7748	resources[0].declarationSourceStart,
7749	resources[resources.length - 1].declarationSourceEnd);	7749	resources[resources.length - 1].declarationSourceEnd);
7750	}	7750	}
		7751	public void cannotInferElidedTypes(AllocationExpression allocationExpression) {
		7752	this.handle(
		7753	IProblem.CannotInferElidedTypes,
		7754	NoArgument,
		7755	NoArgument,
		7756	allocationExpression.sourceStart,
		7757	allocationExpression.sourceEnd);
		7758	}
7751	}	7759	}

Lines 639-644 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/problem/messages.properties (+1 lines)
639	875 = Multi-catch parameters are not allowed for source level below 1.7	639	875 = Multi-catch parameters are not allowed for source level below 1.7
640	876 = Invocation of polymorphic methods not allowed for source level below 1.7	640	876 = Invocation of polymorphic methods not allowed for source level below 1.7
641	877 = Cannot switch on a value of type {0}. Only convertible int values, strings or enum constants are permitted	641	877 = Cannot switch on a value of type {0}. Only convertible int values, strings or enum constants are permitted
		642	878 = Cannot infer elided type(s)
642		643
643	### ELABORATIONS	644	### ELABORATIONS
644	## Access restrictions	645	## Access restrictions

Return to bug 339478

Lines 253-259 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java (-6 / +7 lines)
253	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes, i);	253	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes, i);
254	return null;	254	return null;
255	}	255	}
256	checkBounds = false; // successful <> inference needs no bounds check, we will scream foul if needed during inference.
257	}	256	}
258	// check parameterizing non-static member type of raw type	257	// check parameterizing non-static member type of raw type
259	if (typeIsConsistent && !currentType.isStatic()) {	258	if (typeIsConsistent && !currentType.isStatic()) {
Lines 265-275 Link Here
265	}	264	}
266	}	265	}
267	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, qualifyingType);	266	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, qualifyingType);
268	// check argument type compatibility	267	// check argument type compatibility for non <> cases - <> case needs no bounds check, we will scream foul if needed during inference.
269	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution	268	if (!isDiamond) {
270	parameterizedType.boundCheck(scope, args);	269	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution
271	else	270	parameterizedType.boundCheck(scope, args);
272	scope.deferBoundCheck(this);	271	else
		272	scope.deferBoundCheck(this);
		273	}
273	qualifyingType = parameterizedType;	274	qualifyingType = parameterizedType;
274	} else {	275	} else {
275	ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();	276	ReferenceBinding currentOriginal = (ReferenceBinding)currentType.original();

Lines 209-214 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (-7 / +9 lines)
209	return null;	209	return null;
210	}	210	}
211		211
		212	final boolean isDiamond = (this.bits & ASTNode.IsDiamond) != 0;
212	TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();	213	TypeVariableBinding[] typeVariables = currentOriginal.typeVariables();
213	if (typeVariables == Binding.NO_TYPE_VARIABLES) { // non generic invoked with arguments	214	if (typeVariables == Binding.NO_TYPE_VARIABLES) { // non generic invoked with arguments
214	boolean isCompliant15 = scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_5;	215	boolean isCompliant15 = scope.compilerOptions().originalSourceLevel >= ClassFileConstants.JDK1_5;
Lines 227-237 Link Here
227	}	228	}
228	// if missing generic type, and compliance >= 1.5, then will rebuild a parameterized binding	229	// if missing generic type, and compliance >= 1.5, then will rebuild a parameterized binding
229	} else if (argLength != typeVariables.length) {	230	} else if (argLength != typeVariables.length) {
230	if ((this.bits & ASTNode.IsDiamond) == 0) { // check arity, IsDiamond never set for 1.6-	231	if (!isDiamond) { // check arity, IsDiamond never set for 1.6-
231	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);	232	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);
232	return null;	233	return null;
233	}	234	}
234	checkBounds = false; // successful <> inference needs no bounds check, we will scream foul if needed during inference.
235	} else if (!currentType.isStatic()) {	235	} else if (!currentType.isStatic()) {
236	ReferenceBinding actualEnclosing = currentType.enclosingType();	236	ReferenceBinding actualEnclosing = currentType.enclosingType();
237	if (actualEnclosing != null && actualEnclosing.isRawType()){	237	if (actualEnclosing != null && actualEnclosing.isRawType()){
Lines 242-252 Link Here
242	}	242	}
243		243
244	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, enclosingType);	244	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType(currentOriginal, argTypes, enclosingType);
245	// check argument type compatibility	245	// check argument type compatibility for non <> cases - <> case needs no bounds check, we will scream foul if needed during inference.
246	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution	246	if (!isDiamond) {
247	parameterizedType.boundCheck(scope, this.typeArguments);	247	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution
248	else	248	parameterizedType.boundCheck(scope, this.typeArguments);
249	scope.deferBoundCheck(this);	249	else
		250	scope.deferBoundCheck(this);
		251	}
250	if (isTypeUseDeprecated(parameterizedType, scope))	252	if (isTypeUseDeprecated(parameterizedType, scope))
251	reportDeprecatedType(parameterizedType, scope);	253	reportDeprecatedType(parameterizedType, scope);
252		254

Lines 25-30 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java (+134 lines)
25	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;	25	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
26	import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;	26	import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;
27	import org.eclipse.jdt.internal.compiler.util.ObjectVector;	27	import org.eclipse.jdt.internal.compiler.util.ObjectVector;
		28	import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
28	import org.eclipse.jdt.internal.compiler.util.SimpleSet;	29	import org.eclipse.jdt.internal.compiler.util.SimpleSet;
29		30
30	public abstract class Scope {	31	public abstract class Scope {
Lines 4023-4026 Link Here
4023	int startIndex() {	4024	int startIndex() {
4024	return 0;	4025	return 0;
4025	}	4026	}
		4027	/* Given an allocation type and arguments at the allocation site, answer a synthetic generic static factory method
		4028	that could instead be invoked with identical results. Return null if no compatible, visible, most specific method
		4029	could be found. This method is modeled after Scope.getConstructor and Scope.getMethod.
		4030	*/
		4031	public MethodBinding getStaticFactory (ReferenceBinding allocationType, TypeBinding[] argumentTypes, final InvocationSite allocationSite) {
		4032	TypeVariableBinding[] classTypeVariables = allocationType.typeVariables();
		4033	int classTypeVariablesArity = classTypeVariables.length;
		4034	MethodBinding[] methods = allocationType.getMethods(TypeConstants.INIT, argumentTypes.length);
		4035	MethodBinding [] staticFactories = new MethodBinding[methods.length];
		4036	int sfi = 0;
		4037	for (int i = 0, length = methods.length; i < length; i++) {
		4038	MethodBinding method = methods[i];
		4039
		4040	TypeVariableBinding[] methodTypeVariables = method.typeVariables();
		4041	int methodTypeVariablesArity = methodTypeVariables.length;
		4042
		4043	final TypeBinding[] genericTypeArguments = allocationSite.genericTypeArguments();
		4044	if (genericTypeArguments != null && genericTypeArguments.length < methodTypeVariablesArity)
		4045	continue; // wrong tree, don't bark.
		4046	MethodBinding staticFactory = new MethodBinding(method.modifiers \| ClassFileConstants.AccStatic, TypeConstants.SYNTHETIC_STATIC_FACTORY,
		4047	null, null, null, method.declaringClass);
		4048	staticFactory.typeVariables = new TypeVariableBinding[classTypeVariablesArity + (genericTypeArguments == null ? methodTypeVariablesArity : 0)];
		4049	final SimpleLookupTable map = new SimpleLookupTable(classTypeVariablesArity + methodTypeVariablesArity);
		4050	// Rename each type variable T of the type to T'
		4051	final LookupEnvironment environment = environment();
		4052	for (int j = 0; j < classTypeVariablesArity; j++) {
		4053	map.put(classTypeVariables[j], staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(classTypeVariables[j].sourceName, "'".toCharArray()), //$NON-NLS-1$
		4054	staticFactory, j, environment));
		4055	}
		4056	// Rename each type variable U of method U to U'' if not explicitly parameterized. Otherwise use the parameterizing type.
		4057	for (int j = classTypeVariablesArity, max = classTypeVariablesArity + methodTypeVariablesArity; j < max; j++) {
		4058	map.put(methodTypeVariables[j - classTypeVariablesArity],
		4059	genericTypeArguments != null ? genericTypeArguments[j - classTypeVariablesArity] :
		4060	(staticFactory.typeVariables[j] = new TypeVariableBinding(CharOperation.concat(methodTypeVariables[j - classTypeVariablesArity].sourceName, "''".toCharArray()), //$NON-NLS-1$
		4061	staticFactory, j, environment)));
		4062	}
		4063	final Scope scope = this;
		4064	Substitution substitution = new Substitution() {
		4065	public LookupEnvironment environment() {
		4066	return scope.environment();
		4067	}
		4068	public boolean isRawSubstitution() {
		4069	return false;
		4070	}
		4071	public TypeBinding substitute(TypeVariableBinding typeVariable) {
		4072	return (TypeBinding) map.get(typeVariable);
		4073	}
		4074	};
		4075
		4076	// initialize new variable bounds
		4077	for (int j = 0, max = classTypeVariablesArity + methodTypeVariablesArity; j < max; j++) {
		4078	TypeVariableBinding originalVariable = j < classTypeVariablesArity ? classTypeVariables[j] : methodTypeVariables[j - classTypeVariablesArity];
		4079	TypeBinding substitutedType = (TypeBinding) map.get(originalVariable);
		4080	if (substitutedType instanceof TypeVariableBinding) {
		4081	TypeVariableBinding substitutedVariable = (TypeVariableBinding) substitutedType;
		4082	TypeBinding substitutedSuperclass = Scope.substitute(substitution, originalVariable.superclass);
		4083	ReferenceBinding[] substitutedInterfaces = Scope.substitute(substitution, originalVariable.superInterfaces);
		4084	if (originalVariable.firstBound != null) {
		4085	substitutedVariable.firstBound = originalVariable.firstBound == originalVariable.superclass
		4086	? substitutedSuperclass // could be array type or interface
		4087	: substitutedInterfaces[0];
		4088	}
		4089	switch (substitutedSuperclass.kind()) {
		4090	case Binding.ARRAY_TYPE :
4091	substitutedVariable.superclass = environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
4092	substitutedVariable.superInterfaces = substitutedInterfaces;
4093	break;
4094	default:
4095	if (substitutedSuperclass.isInterface()) {
4096	substitutedVariable.superclass = environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null);
4097	int interfaceCount = substitutedInterfaces.length;
4098	System.arraycopy(substitutedInterfaces, 0, substitutedInterfaces = new ReferenceBinding[interfaceCount+1], 1, interfaceCount);
4099	substitutedInterfaces[0] = (ReferenceBinding) substitutedSuperclass;
4100	substitutedVariable.superInterfaces = substitutedInterfaces;
4101	} else {
4102	substitutedVariable.superclass = (ReferenceBinding) substitutedSuperclass; // typeVar was extending other typeVar which got substituted with interface
4103	substitutedVariable.superInterfaces = substitutedInterfaces;
4104	}
4105	}
4106	}
4107	}
4108	TypeVariableBinding[] returnTypeParameters = new TypeVariableBinding[classTypeVariablesArity];
4109	for (int j = 0; j < classTypeVariablesArity; j++) {
4110	returnTypeParameters[j] = (TypeVariableBinding) map.get(classTypeVariables[j]);
4111	}
4112	staticFactory.returnType = environment.createParameterizedType(allocationType, returnTypeParameters, allocationType.enclosingType());
4113	staticFactory.parameters = Scope.substitute(substitution, method.parameters);
4114	staticFactory.thrownExceptions = Scope.substitute(substitution, method.thrownExceptions);
4115	if (staticFactory.thrownExceptions == null) {
4116	staticFactory.thrownExceptions = Binding.NO_EXCEPTIONS;
4117	}
4118	staticFactories[sfi++] = new ParameterizedMethodBinding((ParameterizedTypeBinding) environment.convertToParameterizedType(staticFactory.declaringClass),
4119	staticFactory);
4120	}
4121	if (sfi != methods.length) {
4122	System.arraycopy(staticFactories, 0, staticFactories = new MethodBinding[sfi], 0, sfi);
4123	}
4124	InvocationSite site = new InvocationSite() { // Alternate site to not expose the generic type arguments as they have already been substituted.
4125	public int sourceStart() { return allocationSite.sourceStart(); }
4126	public int sourceEnd() { return allocationSite.sourceEnd(); }
4127	public void setFieldIndex(int depth) { allocationSite.setFieldIndex(depth); }
4128	public void setDepth(int depth) { allocationSite.setDepth(depth);}
4129	public void setActualReceiverType(ReferenceBinding receiverType) { allocationSite.setActualReceiverType(receiverType);}
4130	public boolean isTypeAccess() { return allocationSite.isTypeAccess(); }
4131	public boolean isSuperAccess() { return allocationSite.isSuperAccess(); }
4132	public TypeBinding[] genericTypeArguments() { return null; }
4133	public TypeBinding expectedType() { return allocationSite.expectedType(); }
4134	};
4135	MethodBinding[] compatible = new MethodBinding[sfi];
4136	int compatibleIndex = 0;
4137	for (int i = 0; i < sfi; i++) {
4138	MethodBinding compatibleMethod = computeCompatibleMethod(staticFactories[i], argumentTypes, site);
4139	if (compatibleMethod != null) {
4140	if (compatibleMethod.isValidBinding())
4141	compatible[compatibleIndex++] = compatibleMethod;
4142	}
4143	}
4144
4145	if (compatibleIndex == 0) {
4146	return null;
4147	}
4148	MethodBinding[] visible = new MethodBinding[compatibleIndex];
4149	int visibleIndex = 0;
4150	for (int i = 0; i < compatibleIndex; i++) {
4151	MethodBinding method = compatible[i];
4152	if (method.canBeSeenBy(allocationSite, this))
4153	visible[visibleIndex++] = method;
4154	}
4155	if (visibleIndex == 0) {
4156	return null;
4157	}
4158	return visibleIndex == 1 ? visible[0] : mostSpecificMethodBinding(visible, visibleIndex, argumentTypes, allocationSite, allocationType);
4159	}
4026	}	4160	}