| /******************************************************************************* |
| * Copyright (c) 2000, 2004 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.compiler.lookup; |
| |
| import java.util.HashMap; |
| import java.util.Map; |
| import org.eclipse.jdt.internal.compiler.ast.MessageSend; |
| import org.eclipse.jdt.internal.compiler.ast.Wildcard; |
| |
| /** |
| * Binding denoting a generic method after type parameter substitutions got performed. |
| * On parameterized type bindings, all methods got substituted, regardless whether |
| * their signature did involve generics or not, so as to get the proper declaringClass for |
| * these methods. |
| */ |
| public class ParameterizedGenericMethodBinding extends ParameterizedMethodBinding implements Substitution { |
| |
| public TypeBinding[] typeArguments; |
| private LookupEnvironment environment; |
| public boolean inferredReturnType; |
| |
| /** |
| * Create method of parameterized type, substituting original parameters with type arguments. |
| */ |
| public ParameterizedGenericMethodBinding(MethodBinding originalMethod, TypeBinding[] typeArguments, LookupEnvironment environment) { |
| |
| this.environment = environment; |
| this.modifiers = originalMethod.modifiers; |
| this.selector = originalMethod.selector; |
| this.declaringClass = originalMethod.declaringClass; |
| this.typeVariables = NoTypeVariables; |
| this.typeArguments = typeArguments; |
| this.originalMethod = originalMethod; |
| this.parameters = Scope.substitute(this, originalMethod.parameters); |
| this.thrownExceptions = Scope.substitute(this, originalMethod.thrownExceptions); |
| this.returnType = this.substitute(originalMethod.returnType); |
| } |
| /** |
| * Create raw generic method for raw type (double substitution from type vars with raw type arguments, and erasure of method variables) |
| */ |
| public ParameterizedGenericMethodBinding(MethodBinding originalMethod, RawTypeBinding rawType, LookupEnvironment environment) { |
| |
| TypeVariableBinding[] originalVariables = originalMethod.typeVariables; |
| int length = originalVariables.length; |
| TypeBinding[] rawArguments = new TypeBinding[length]; |
| for (int i = 0; i < length; i++) { |
| rawArguments[i] = originalVariables[i].erasure(); |
| } |
| this.environment = environment; |
| this.modifiers = originalMethod.modifiers; |
| this.selector = originalMethod.selector; |
| this.declaringClass = rawType; |
| this.typeVariables = NoTypeVariables; |
| this.typeArguments = rawArguments; |
| this.originalMethod = originalMethod; |
| boolean isStatic = originalMethod.isStatic(); |
| this.parameters = Scope.substitute(this, |
| isStatic ? originalMethod.parameters : Scope.substitute(rawType, originalMethod.parameters)); |
| this.thrownExceptions = Scope.substitute(this, |
| isStatic ? originalMethod.thrownExceptions : Scope.substitute(rawType, originalMethod.thrownExceptions)); |
| this.returnType = this.substitute(isStatic ? originalMethod.returnType : rawType.substitute(originalMethod.returnType)); |
| } |
| |
| /** |
| * Perform inference of generic method type parameters and/or expected type |
| */ |
| public static MethodBinding computeCompatibleMethod(MethodBinding originalMethod, TypeBinding[] arguments, Scope scope, InvocationSite invocationSite) { |
| |
| ParameterizedGenericMethodBinding methodSubstitute; |
| TypeVariableBinding[] typeVariables = originalMethod.typeVariables; |
| TypeBinding[] substitutes = invocationSite.genericTypeArguments(); |
| |
| if (substitutes != null) { |
| if (substitutes.length != typeVariables.length) { |
| // incompatible due to wrong arity |
| return new ProblemMethodBinding(originalMethod, originalMethod.selector, substitutes, TypeParameterArityMismatch); |
| } |
| methodSubstitute = new ParameterizedGenericMethodBinding(originalMethod, substitutes, scope.environment()); |
| } else { |
| // perform type inference based on argument types and expected type |
| |
| // collect substitutes by pattern matching parameters and arguments |
| int argLength = arguments.length; |
| TypeBinding[] parameters = originalMethod.parameters; |
| int varLength = typeVariables.length; |
| HashMap collectedSubstitutes = new HashMap(varLength); |
| for (int i = 0; i < varLength; i++) |
| collectedSubstitutes.put(typeVariables[i], new TypeBinding[1]); |
| for (int i = 0; i < argLength; i++) |
| parameters[i].collectSubstitutes(arguments[i], collectedSubstitutes); |
| substitutes = new TypeBinding[varLength]; |
| boolean needReturnTypeInference = false; |
| for (int i = 0; i < varLength; i++) { |
| TypeBinding[] variableSubstitutes = (TypeBinding[]) collectedSubstitutes.get(typeVariables[i]); |
| TypeBinding mostSpecificSubstitute = scope.lowerUpperBound(variableSubstitutes); |
| //TypeBinding mostSpecificSubstitute = scope.mostSpecificCommonType(variableSubstitutes); |
| if (mostSpecificSubstitute == null) |
| return null; // incompatible |
| if (mostSpecificSubstitute == VoidBinding) { |
| needReturnTypeInference = true; |
| mostSpecificSubstitute = typeVariables[i]; |
| } |
| substitutes[i] = mostSpecificSubstitute; |
| } |
| // apply inferred variable substitutions |
| methodSubstitute = new ParameterizedGenericMethodBinding(originalMethod, substitutes, scope.environment()); |
| |
| if (needReturnTypeInference && invocationSite instanceof MessageSend) { |
| MessageSend message = (MessageSend) invocationSite; |
| TypeBinding expectedType = message.expectedType; |
| if (expectedType != null) |
| methodSubstitute.inferFromExpectedType(message.expectedType, scope); |
| } |
| } |
| // check bounds |
| for (int i = 0, length = typeVariables.length; i < length; i++) { |
| TypeVariableBinding typeVariable = typeVariables[i]; |
| if (!typeVariable.boundCheck(methodSubstitute, substitutes[i])) |
| // incompatible due to bound check |
| return new ProblemMethodBinding(methodSubstitute, originalMethod.selector, new TypeBinding[]{substitutes[i], typeVariables[i] }, ParameterBoundMismatch); |
| } |
| |
| return methodSubstitute; |
| } |
| |
| public void inferFromExpectedType(TypeBinding expectedType, Scope scope) { |
| if (this.returnType == expectedType) |
| return; |
| if ((this.returnType.tagBits & TagBits.HasTypeVariable) == 0) |
| return; |
| Map substitutes = new HashMap(1); |
| int length = this.typeArguments.length; |
| TypeVariableBinding[] originalVariables = this.original().typeVariables; |
| boolean hasUnboundParameters = false; |
| for (int i = 0; i < length; i++) { |
| if (this.typeArguments[i] == originalVariables[i]) { |
| hasUnboundParameters = true; |
| substitutes.put(originalVariables[i], new TypeBinding[1]); |
| } else { |
| substitutes.put(originalVariables[i], new TypeBinding[] { this.typeArguments[i] }); |
| } |
| } |
| if (!hasUnboundParameters) |
| return; |
| returnType.collectSubstitutes(expectedType, substitutes); |
| for (int i = 0; i < length; i++) { |
| TypeBinding[] variableSubstitutes = (TypeBinding[]) substitutes.get(originalVariables[i]); |
| TypeBinding mostSpecificSubstitute = scope.lowerUpperBound(variableSubstitutes); |
| //TypeBinding mostSpecificSubstitute = scope.mostSpecificCommonType(variableSubstitutes); |
| if (mostSpecificSubstitute == null) { |
| return; // TODO (philippe) should report no way to infer type |
| } |
| if (mostSpecificSubstitute != VoidBinding) |
| this.typeArguments[i] = mostSpecificSubstitute; |
| } |
| TypeBinding oldReturnType = this.returnType; |
| this.returnType = this.substitute(this.returnType); |
| this.inferredReturnType = this.returnType != oldReturnType; |
| this.parameters = Scope.substitute(this, this.parameters); |
| this.thrownExceptions = Scope.substitute(this, this.thrownExceptions); |
| } |
| |
| /** |
| * Returns a type, where original type was substituted using the receiver |
| * parameterized method. |
| */ |
| public TypeBinding substitute(TypeBinding originalType) { |
| |
| if ((originalType.tagBits & TagBits.HasTypeVariable) != 0) { |
| if (originalType.isTypeVariable()) { |
| TypeVariableBinding originalVariable = (TypeVariableBinding) originalType; |
| TypeVariableBinding[] variables = this.originalMethod.typeVariables; |
| int length = variables.length; |
| // check this variable can be substituted given parameterized type |
| if (originalVariable.rank < length && variables[originalVariable.rank] == originalVariable) { |
| return this.typeArguments[originalVariable.rank]; |
| } |
| } else if (originalType.isParameterizedType()) { |
| ParameterizedTypeBinding originalParameterizedType = (ParameterizedTypeBinding) originalType; |
| TypeBinding[] originalArguments = originalParameterizedType.arguments; |
| TypeBinding[] substitutedArguments = Scope.substitute(this, originalArguments); |
| if (substitutedArguments != originalArguments) { |
| identicalVariables: { // if substituted with original variables, then answer the generic type itself |
| TypeVariableBinding[] originalVariables = originalParameterizedType.type.typeVariables(); |
| for (int i = 0, length = originalVariables.length; i < length; i++) { |
| if (substitutedArguments[i] != originalVariables[i]) break identicalVariables; |
| } |
| return originalParameterizedType.type; |
| } |
| return this.environment.createParameterizedType( |
| originalParameterizedType.type, substitutedArguments, originalParameterizedType.enclosingType()); |
| } |
| } else if (originalType.isArrayType()) { |
| TypeBinding originalLeafComponentType = originalType.leafComponentType(); |
| TypeBinding substitute = substitute(originalLeafComponentType); // substitute could itself be array type |
| if (substitute != originalLeafComponentType) { |
| return this.environment.createArrayType(substitute.leafComponentType(), substitute.dimensions() + originalType.dimensions()); |
| } |
| } else if (originalType.isWildcard()) { |
| WildcardBinding wildcard = (WildcardBinding) originalType; |
| if (wildcard.kind != Wildcard.UNBOUND) { |
| TypeBinding originalBound = wildcard.bound; |
| TypeBinding substitutedBound = substitute(originalBound); |
| if (substitutedBound != originalBound) { |
| return this.environment.createWildcard(wildcard.genericType, wildcard.rank, substitutedBound, wildcard.kind); |
| } |
| } |
| } |
| } else if (originalType.isGenericType()) { |
| // treat as if parameterized with its type variables |
| ReferenceBinding originalGenericType = (ReferenceBinding) originalType; |
| TypeVariableBinding[] originalVariables = originalGenericType.typeVariables(); |
| int length = originalVariables.length; |
| TypeBinding[] originalArguments; |
| System.arraycopy(originalVariables, 0, originalArguments = new TypeBinding[length], 0, length); |
| TypeBinding[] substitutedArguments = Scope.substitute(this, originalArguments); |
| if (substitutedArguments != originalArguments) { |
| return this.environment.createParameterizedType( |
| originalGenericType, substitutedArguments, null); |
| } |
| } |
| return originalType; |
| } |
| } |
