org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java - gerrit/aspectj/org.aspectj.shadows - Git at Google

 /*******************************************************************************
  * 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;
     public boolean wasInferred; // only set to true for instances resulting from method invocation inferrence
     public boolean isRaw; // set to true for method behaving as raw for substitution purpose
     public MethodBinding tiebreakMethod;

     /**
      * 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.isRaw = false;
 	    this.originalMethod = originalMethod;
 	    this.parameters = Scope.substitute(this, originalMethod.parameters);
 	    this.thrownExceptions = Scope.substitute(this, originalMethod.thrownExceptions);
 	    this.returnType = this.substitute(originalMethod.returnType);
 	    this.wasInferred = true;// resulting from method invocation inferrence
 	}

 	/**
 	 * Create raw generic method for raw type (double substitution from type vars with raw type arguments, and erasure of method variables)
 	 * Only invoked for non-static generic methods of raw type
 	 */
 	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.isRaw = true;
 	    this.environment = environment;
 		this.modifiers = originalMethod.modifiers;
 		this.selector = originalMethod.selector;
 		this.declaringClass = rawType == null ? originalMethod.declaringClass : rawType;
 	    this.typeVariables = NoTypeVariables;
 	    this.typeArguments = rawArguments;
 	    this.originalMethod = originalMethod;
 		boolean ignoreRawTypeSubstitution = rawType == null || originalMethod.isStatic();
 	    this.parameters = Scope.substitute(this, ignoreRawTypeSubstitution
 	    									? originalMethod.parameters // no substitution if original was static
 	    									: Scope.substitute(rawType, originalMethod.parameters));
 	    this.thrownExceptions = Scope.substitute(this, 	ignoreRawTypeSubstitution
 	    									? originalMethod.thrownExceptions // no substitution if original was static
 	    									: Scope.substitute(rawType, originalMethod.thrownExceptions));
 	    this.returnType = this.substitute(ignoreRawTypeSubstitution
 	    									? originalMethod.returnType // no substitution if original was static
 	    									: rawType.substitute(originalMethod.returnType));
 	    this.wasInferred = false; // not resulting from method invocation inferrence
 	}

 	/**
 	 * 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
 			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]);

 			// collect argument type mapping, handling varargs
 			if (originalMethod.isVarargs()) {
 				int paramLength = parameters.length;
 				int minArgLength = paramLength - 1;
 				int argLength = arguments.length;
 				// process mandatory arguments
 				for (int i = 0; i < minArgLength; i++)
 					parameters[i].collectSubstitutes(arguments[i], collectedSubstitutes);
 				// process optional arguments
 				if (minArgLength < argLength) {
 					TypeBinding varargType = parameters[minArgLength]; // last arg type - as is ?
 					if (paramLength != argLength // argument is passed as is ?
 							||  (arguments[minArgLength] != NullBinding
 									&& (arguments[minArgLength].dimensions() != varargType.dimensions()))) {
 						varargType = ((ArrayBinding)varargType).elementsType(); // eliminate one array dimension
 					}
 					for (int i = minArgLength; i < argLength; i++)
 						varargType.collectSubstitutes(arguments[i], collectedSubstitutes);
 				}
 			} else {
 				int paramLength = parameters.length;
 				for (int i = 0; i < paramLength; i++)
 					parameters[i].collectSubstitutes(arguments[i], collectedSubstitutes);
 			}
 			boolean needReturnTypeInference = false;
 			if (collectedSubstitutes.isEmpty()) {
 				// raw generic method inferred
 				methodSubstitute = new ParameterizedGenericMethodBinding(originalMethod, (RawTypeBinding)null, scope.environment());
 			} else {
 				substitutes = new TypeBinding[varLength];
 				for (int i = 0; i < varLength; i++) {
 					TypeBinding[] variableSubstitutes = (TypeBinding[]) collectedSubstitutes.get(typeVariables[i]);
 					TypeBinding mostSpecificSubstitute = scope.lowerUpperBound(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) {
 					// 15.12.2.8 - if no expected type, then assume Object
 					// actually it rather seems to handle the returned variable case by expecting its erasure instead
 					if (methodSubstitute.returnType.isTypeVariable()) {
 						expectedType = methodSubstitute.returnType.erasure();
 					} else {
 						expectedType =scope.getJavaLangObject();
 					}
 				}
 				methodSubstitute.inferFromExpectedType(expectedType, scope);
 			}
 		}
 		// check bounds
 		if (!methodSubstitute.isRaw) {
 			for (int i = 0, length = typeVariables.length; i < length; i++) {
 			    TypeVariableBinding typeVariable = typeVariables[i];
 			    TypeBinding substitute = substitutes[i];
 			    if (!typeVariable.boundCheck(methodSubstitute, substitute))
 			        // incompatible due to bound check
 			        return new ProblemMethodBinding(methodSubstitute, originalMethod.selector, new TypeBinding[]{substitutes[i], typeVariables[i] }, ParameterBoundMismatch);
 			}
 		}

 		return methodSubstitute;
 	}

 	/*
 	 * parameterizedDeclaringUniqueKey dot selector originalMethodGenericSignature percent typeArguments
 	 * p.X<U> { <T> void bar(T t, U u) { new X<String>().bar(this, "") } } --> Lp/X<Ljava/lang/String;>;.bar<T:Ljava/lang/Object;>(TT;TU;)V%<Lp/X;>
 	 */
 	public char[] computeUniqueKey() {
 		if (this.isRaw)
 			return super.computeUniqueKey();
 		StringBuffer buffer = new StringBuffer();
 		buffer.append(super.computeUniqueKey());
 		buffer.append('%');
 		buffer.append('<');
 		int length = this.typeArguments.length;
 		for (int i = 0; i < length; i++) {
 			TypeBinding typeArgument = this.typeArguments[i];
 			buffer.append(typeArgument.computeUniqueKey());
 		}
 		buffer.append('>');
 		int resultLength = buffer.length();
 		char[] result = new char[resultLength];
 		buffer.getChars(0, resultLength, result, 0);
 		return result;

 	}

 	/**
 	 * Returns true if some parameters got substituted.
 	 * NOTE: generic method invocation delegates to its declaring method (could be a parameterized one)
 	 */
 	public boolean hasSubstitutedParameters() {
 		// generic parameterized method can represent either an invocation or a raw generic method
 		if (this.wasInferred)
 			return this.originalMethod.hasSubstitutedParameters();
 		return super.hasSubstitutedParameters();
 	}
 	/**
 	 * Returns true if the return type got substituted.
 	 * NOTE: generic method invocation delegates to its declaring method (could be a parameterized one)
 	 */
 	public boolean hasSubstitutedReturnType() {
 		if (this.wasInferred)
 			return this.originalMethod.hasSubstitutedReturnType();
 		return super.hasSubstitutedReturnType();
 	}

 	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);
 	    if (substitutes.isEmpty()) {
 	    	// raw generic method inferred
 	    	this.isRaw = true;
 	    	for (int i = 0; i < length; i++) {
 	    		this.typeArguments[i] = originalVariables[i].erasure();
 	    	}
 	    } else {
 			for (int i = 0; i < length; i++) {
 				TypeBinding[] variableSubstitutes = (TypeBinding[]) substitutes.get(originalVariables[i]);
 				TypeBinding mostSpecificSubstitute = scope.lowerUpperBound(variableSubstitutes);
 				if (mostSpecificSubstitute == null) {
 				    return; // TODO (philippe) should report no way to infer type
 				}
 				if (mostSpecificSubstitute == VoidBinding) {
 					// 15.12.2.8 - any remaining variable is assumed to be its erasure
 					mostSpecificSubstitute = originalVariables[i].erasure();
 				}
 				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) {

 		switch (originalType.kind()) {

 			case Binding.TYPE_PARAMETER:
 		        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];
 		        }
 		        if (this.declaringClass instanceof Substitution) {
 		        	return ((Substitution)this.declaringClass).substitute(originalType);
 		        }
 		        break;

 			case Binding.PARAMETERIZED_TYPE:
 				ParameterizedTypeBinding originalParameterizedType = (ParameterizedTypeBinding) originalType;
 				ReferenceBinding originalEnclosing = originalType.enclosingType();
 				ReferenceBinding substitutedEnclosing = originalEnclosing;
 				if (originalEnclosing != null) {
 					substitutedEnclosing = (ReferenceBinding) this.substitute(originalEnclosing);
 				}
 				if (this.isRaw) {
 					return this.environment.createRawType(originalParameterizedType.type, substitutedEnclosing);
 				}
 				TypeBinding[] originalArguments = originalParameterizedType.arguments;
 				TypeBinding[] substitutedArguments = originalArguments;
 				if (originalArguments != null) {
 					substitutedArguments = Scope.substitute(this, originalArguments);
 				}
 				if (substitutedArguments != originalArguments || substitutedEnclosing != originalEnclosing) {
 					identicalVariables: { // if substituted with original variables, then answer the generic type itself
 						if (substitutedEnclosing != originalEnclosing) break identicalVariables;
 						TypeVariableBinding[] originalVariables = originalParameterizedType.type.typeVariables();
 						length = originalVariables.length;
 						for (int i = 0; i < length; i++) {
 							if (substitutedArguments[i] != originalVariables[i]) break identicalVariables;
 						}
 						return originalParameterizedType.type;
 					}
 					return this.environment.createParameterizedType(
 							originalParameterizedType.type, substitutedArguments, substitutedEnclosing);
 				}
 				break;

 			case Binding.ARRAY_TYPE:
 				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());
 				}
 				break;

 			case Binding.WILDCARD_TYPE:
 		        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);
 			        }
 		        }
 		        break;


 			case Binding.GENERIC_TYPE:
 			    // treat as if parameterized with its type variables
 				ReferenceBinding originalGenericType = (ReferenceBinding) originalType;
 				originalEnclosing = originalType.enclosingType();
 				substitutedEnclosing = originalEnclosing;
 				if (originalEnclosing != null) {
 					substitutedEnclosing = (ReferenceBinding) this.substitute(originalEnclosing);
 				}
 				if (this.isRaw) {
 					return this.environment.createRawType(originalGenericType, substitutedEnclosing);
 				}
 				TypeVariableBinding[] originalVariables = originalGenericType.typeVariables();
 				length = originalVariables.length;
 				System.arraycopy(originalVariables, 0, originalArguments = new TypeBinding[length], 0, length);
 				substitutedArguments = Scope.substitute(this, originalArguments);
 				if (substitutedArguments != originalArguments || substitutedEnclosing != originalEnclosing) {
 					return this.environment.createParameterizedType(
 							originalGenericType, substitutedArguments, substitutedEnclosing);
 				}
 				break;
 	    }
 	    return originalType;
 	}
 	/**
 	 * Returns the method to use during tiebreak (usually the method itself).
 	 * For generic method invocations, tiebreak needs to use generic method with erasure substitutes.
 	 */
 	public MethodBinding tiebreakMethod() {
 		if (this.tiebreakMethod == null) {
 			this.tiebreakMethod = new ParameterizedGenericMethodBinding(this.originalMethod, (RawTypeBinding)null, this.environment);
 		}
 		return this.tiebreakMethod;
 	}
 }
	/*******************************************************************************
	* 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;
	public boolean wasInferred; // only set to true for instances resulting from method invocation inferrence
	public boolean isRaw; // set to true for method behaving as raw for substitution purpose
	public MethodBinding tiebreakMethod;

	/**
	* 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.isRaw = false;
	this.originalMethod = originalMethod;
	this.parameters = Scope.substitute(this, originalMethod.parameters);
	this.thrownExceptions = Scope.substitute(this, originalMethod.thrownExceptions);
	this.returnType = this.substitute(originalMethod.returnType);
	this.wasInferred = true;// resulting from method invocation inferrence
	}

	/**
	* Create raw generic method for raw type (double substitution from type vars with raw type arguments, and erasure of method variables)
	* Only invoked for non-static generic methods of raw type
	*/
	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.isRaw = true;
	this.environment = environment;
	this.modifiers = originalMethod.modifiers;
	this.selector = originalMethod.selector;
	this.declaringClass = rawType == null ? originalMethod.declaringClass : rawType;
	this.typeVariables = NoTypeVariables;
	this.typeArguments = rawArguments;
	this.originalMethod = originalMethod;
	boolean ignoreRawTypeSubstitution = rawType == null \|\| originalMethod.isStatic();
	this.parameters = Scope.substitute(this, ignoreRawTypeSubstitution
	? originalMethod.parameters // no substitution if original was static
	: Scope.substitute(rawType, originalMethod.parameters));
	this.thrownExceptions = Scope.substitute(this, ignoreRawTypeSubstitution
	? originalMethod.thrownExceptions // no substitution if original was static
	: Scope.substitute(rawType, originalMethod.thrownExceptions));
	this.returnType = this.substitute(ignoreRawTypeSubstitution
	? originalMethod.returnType // no substitution if original was static
	: rawType.substitute(originalMethod.returnType));
	this.wasInferred = false; // not resulting from method invocation inferrence
	}

	/**
	* 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
	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]);

	// collect argument type mapping, handling varargs
	if (originalMethod.isVarargs()) {
	int paramLength = parameters.length;
	int minArgLength = paramLength - 1;
	int argLength = arguments.length;
	// process mandatory arguments
	for (int i = 0; i < minArgLength; i++)
	parameters[i].collectSubstitutes(arguments[i], collectedSubstitutes);
	// process optional arguments
	if (minArgLength < argLength) {
	TypeBinding varargType = parameters[minArgLength]; // last arg type - as is ?
	if (paramLength != argLength // argument is passed as is ?
	\|\| (arguments[minArgLength] != NullBinding
	&& (arguments[minArgLength].dimensions() != varargType.dimensions()))) {
	varargType = ((ArrayBinding)varargType).elementsType(); // eliminate one array dimension
	}
	for (int i = minArgLength; i < argLength; i++)
	varargType.collectSubstitutes(arguments[i], collectedSubstitutes);
	}
	} else {
	int paramLength = parameters.length;
	for (int i = 0; i < paramLength; i++)
	parameters[i].collectSubstitutes(arguments[i], collectedSubstitutes);
	}
	boolean needReturnTypeInference = false;
	if (collectedSubstitutes.isEmpty()) {
	// raw generic method inferred
	methodSubstitute = new ParameterizedGenericMethodBinding(originalMethod, (RawTypeBinding)null, scope.environment());
	} else {
	substitutes = new TypeBinding[varLength];
	for (int i = 0; i < varLength; i++) {
	TypeBinding[] variableSubstitutes = (TypeBinding[]) collectedSubstitutes.get(typeVariables[i]);
	TypeBinding mostSpecificSubstitute = scope.lowerUpperBound(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) {
	// 15.12.2.8 - if no expected type, then assume Object
	// actually it rather seems to handle the returned variable case by expecting its erasure instead
	if (methodSubstitute.returnType.isTypeVariable()) {
	expectedType = methodSubstitute.returnType.erasure();
	} else {
	expectedType =scope.getJavaLangObject();
	}
	}
	methodSubstitute.inferFromExpectedType(expectedType, scope);
	}
	}
	// check bounds
	if (!methodSubstitute.isRaw) {
	for (int i = 0, length = typeVariables.length; i < length; i++) {
	TypeVariableBinding typeVariable = typeVariables[i];
	TypeBinding substitute = substitutes[i];
	if (!typeVariable.boundCheck(methodSubstitute, substitute))
	// incompatible due to bound check
	return new ProblemMethodBinding(methodSubstitute, originalMethod.selector, new TypeBinding[]{substitutes[i], typeVariables[i] }, ParameterBoundMismatch);
	}
	}

	return methodSubstitute;
	}

	/*
	* parameterizedDeclaringUniqueKey dot selector originalMethodGenericSignature percent typeArguments
	* p.X<U> { <T> void bar(T t, U u) { new X<String>().bar(this, "") } } --> Lp/X<Ljava/lang/String;>;.bar<T:Ljava/lang/Object;>(TT;TU;)V%<Lp/X;>
	*/
	public char[] computeUniqueKey() {
	if (this.isRaw)
	return super.computeUniqueKey();
	StringBuffer buffer = new StringBuffer();
	buffer.append(super.computeUniqueKey());
	buffer.append('%');
	buffer.append('<');
	int length = this.typeArguments.length;
	for (int i = 0; i < length; i++) {
	TypeBinding typeArgument = this.typeArguments[i];
	buffer.append(typeArgument.computeUniqueKey());
	}
	buffer.append('>');
	int resultLength = buffer.length();
	char[] result = new char[resultLength];
	buffer.getChars(0, resultLength, result, 0);
	return result;

	}

	/**
	* Returns true if some parameters got substituted.
	* NOTE: generic method invocation delegates to its declaring method (could be a parameterized one)
	*/
	public boolean hasSubstitutedParameters() {
	// generic parameterized method can represent either an invocation or a raw generic method
	if (this.wasInferred)
	return this.originalMethod.hasSubstitutedParameters();
	return super.hasSubstitutedParameters();
	}
	/**
	* Returns true if the return type got substituted.
	* NOTE: generic method invocation delegates to its declaring method (could be a parameterized one)
	*/
	public boolean hasSubstitutedReturnType() {
	if (this.wasInferred)
	return this.originalMethod.hasSubstitutedReturnType();
	return super.hasSubstitutedReturnType();
	}

	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);
	if (substitutes.isEmpty()) {
	// raw generic method inferred
	this.isRaw = true;
	for (int i = 0; i < length; i++) {
	this.typeArguments[i] = originalVariables[i].erasure();
	}
	} else {
	for (int i = 0; i < length; i++) {
	TypeBinding[] variableSubstitutes = (TypeBinding[]) substitutes.get(originalVariables[i]);
	TypeBinding mostSpecificSubstitute = scope.lowerUpperBound(variableSubstitutes);
	if (mostSpecificSubstitute == null) {
	return; // TODO (philippe) should report no way to infer type
	}
	if (mostSpecificSubstitute == VoidBinding) {
	// 15.12.2.8 - any remaining variable is assumed to be its erasure
	mostSpecificSubstitute = originalVariables[i].erasure();
	}
	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) {

	switch (originalType.kind()) {

	case Binding.TYPE_PARAMETER:
	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];
	}
	if (this.declaringClass instanceof Substitution) {
	return ((Substitution)this.declaringClass).substitute(originalType);
	}
	break;

	case Binding.PARAMETERIZED_TYPE:
	ParameterizedTypeBinding originalParameterizedType = (ParameterizedTypeBinding) originalType;
	ReferenceBinding originalEnclosing = originalType.enclosingType();
	ReferenceBinding substitutedEnclosing = originalEnclosing;
	if (originalEnclosing != null) {
	substitutedEnclosing = (ReferenceBinding) this.substitute(originalEnclosing);
	}
	if (this.isRaw) {
	return this.environment.createRawType(originalParameterizedType.type, substitutedEnclosing);
	}
	TypeBinding[] originalArguments = originalParameterizedType.arguments;
	TypeBinding[] substitutedArguments = originalArguments;
	if (originalArguments != null) {
	substitutedArguments = Scope.substitute(this, originalArguments);
	}
	if (substitutedArguments != originalArguments \|\| substitutedEnclosing != originalEnclosing) {
	identicalVariables: { // if substituted with original variables, then answer the generic type itself
	if (substitutedEnclosing != originalEnclosing) break identicalVariables;
	TypeVariableBinding[] originalVariables = originalParameterizedType.type.typeVariables();
	length = originalVariables.length;
	for (int i = 0; i < length; i++) {
	if (substitutedArguments[i] != originalVariables[i]) break identicalVariables;
	}
	return originalParameterizedType.type;
	}
	return this.environment.createParameterizedType(
	originalParameterizedType.type, substitutedArguments, substitutedEnclosing);
	}
	break;

	case Binding.ARRAY_TYPE:
	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());
	}
	break;

	case Binding.WILDCARD_TYPE:
	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);
	}
	}
	break;


	case Binding.GENERIC_TYPE:
	// treat as if parameterized with its type variables
	ReferenceBinding originalGenericType = (ReferenceBinding) originalType;
	originalEnclosing = originalType.enclosingType();
	substitutedEnclosing = originalEnclosing;
	if (originalEnclosing != null) {
	substitutedEnclosing = (ReferenceBinding) this.substitute(originalEnclosing);
	}
	if (this.isRaw) {
	return this.environment.createRawType(originalGenericType, substitutedEnclosing);
	}
	TypeVariableBinding[] originalVariables = originalGenericType.typeVariables();
	length = originalVariables.length;
	System.arraycopy(originalVariables, 0, originalArguments = new TypeBinding[length], 0, length);
	substitutedArguments = Scope.substitute(this, originalArguments);
	if (substitutedArguments != originalArguments \|\| substitutedEnclosing != originalEnclosing) {
	return this.environment.createParameterizedType(
	originalGenericType, substitutedArguments, substitutedEnclosing);
	}
	break;
	}
	return originalType;
	}
	/**
	* Returns the method to use during tiebreak (usually the method itself).
	* For generic method invocations, tiebreak needs to use generic method with erasure substitutes.
	*/
	public MethodBinding tiebreakMethod() {
	if (this.tiebreakMethod == null) {
	this.tiebreakMethod = new ParameterizedGenericMethodBinding(this.originalMethod, (RawTypeBinding)null, this.environment);
	}
	return this.tiebreakMethod;
	}
	}