Attachment #45270 for bug #111086




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

import java.util.Map;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;

	 *   A = F   corresponds to:      F.collectSubstitutes(..., A, ..., 0)
	 *   A >> F   corresponds to:   F.collectSubstitutes(..., A, ..., 2)
	 */
	public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
		
		if ((this.tagBits & TagBits.HasTypeVariable) == 0) return;
		if (actualType == TypeBinding.NULL) return;

		// collect through enclosing type
		ReferenceBinding formalEnclosingType = formalEquivalent.enclosingType();
		if (formalEnclosingType != null) {
			formalEnclosingType.collectSubstitutes(scope, actualEquivalent.enclosingType(), inferenceContext, constraint);
		}
		// collect through type arguments
		if (this.arguments == null) return;

        		formalArguments = ((ParameterizedTypeBinding)formalEquivalent).arguments;
        		break;
        	case Binding.RAW_TYPE :
        		if (!inferenceContext.checkRawSubstitution()) {
	           		inferenceContext.status = InferenceContext.FAILED; // marker for impossible inference
        		}
        		return;
        	default :
        		return;

        		actualArguments = ((ParameterizedTypeBinding)actualEquivalent).arguments;
        		break;
        	case Binding.RAW_TYPE :
        		if (!inferenceContext.checkRawSubstitution()) {
	           		inferenceContext.status = InferenceContext.FAILED; // marker for impossible inference
        			substitutes.put(TypeBinding.VOID, Binding.NO_TYPES); // marker for impossible inference
        		}
        		return;
        	default :
        		return;
        }
        inferenceContext.depth++;
        for (int i = 0, length = formalArguments.length; i < length; i++) {
        	TypeBinding formalArgument = formalArguments[i];
        	TypeBinding actualArgument = actualArguments[i];
        	if (formalArgument.isWildcard()) {
                formalArgument.collectSubstitutes(scope, actualArgument, inferenceContext, constraint);
                continue;
        	} else if (actualArgument.isWildcard()){
    			WildcardBinding actualWildcardArgument = (WildcardBinding) actualArgument;

    				if (constraint == TypeConstants.CONSTRAINT_SUPER) { // JLS 15.12.7, p.459
						switch(actualWildcardArgument.boundKind) {
		    				case Wildcard.EXTENDS :
		    					formalArgument.collectSubstitutes(scope, actualWildcardArgument.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
		    					continue;
		    				case Wildcard.SUPER :
		    					formalArgument.collectSubstitutes(scope, actualWildcardArgument.bound, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
		    					continue;
		    				default :
		    					continue; // cannot infer anything further from unbound wildcard

    			}
        	}
        	// by default, use EQUAL constraint
            formalArgument.collectSubstitutes(scope, actualArgument, inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
        }
        inferenceContext.depth--;
	}
	
	/**

Lines 17-23 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java (-2 / +2 lines)
17	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	17	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
18	import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;	18	import org.eclipse.jdt.internal.compiler.codegen.ConstantPool;
19		19
20	public class MethodBinding extends Binding implements TypeConstants {	20	public class MethodBinding extends Binding {
21		21
22	public int modifiers;	22	public int modifiers;
23	public char[] selector;	23	public char[] selector;
Lines 537-543 Link Here
537	* Answer true if the receiver is a "public static void main(String[])" method	537	* Answer true if the receiver is a "public static void main(String[])" method
538	*/	538	*/
539	public final boolean isMain() {	539	public final boolean isMain() {
540	if (this.selector.length == 4 && CharOperation.equals(this.selector, MAIN)	540	if (this.selector.length == 4 && CharOperation.equals(this.selector, TypeConstants.MAIN)
541	&& ((this.modifiers & (ClassFileConstants.AccPublic \| ClassFileConstants.AccStatic)) != 0)	541	&& ((this.modifiers & (ClassFileConstants.AccPublic \| ClassFileConstants.AccStatic)) != 0)
542	&& TypeBinding.VOID == this.returnType	542	&& TypeBinding.VOID == this.returnType
543	&& this.parameters.length == 1) {	543	&& this.parameters.length == 1) {




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

import java.util.HashMap;
import java.util.Map;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;

/**

    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
    private MethodBinding tiebreakMethod;
    public boolean isUnchecked; // transient flag set during inference (warning: bindings are shared, so flag cannot be trusted beyond)
	
	/**
	 * Perform inference of generic method type parameters and/or expected type

				
			// initializes the map of substitutes (var --> type[][]{ equal, extends, super}
			TypeBinding[] parameters = originalMethod.parameters;
			InferenceContext inferenceContext = new InferenceContext(originalMethod);
			methodSubstitute = inferFromArgumentTypes(scope, originalMethod, arguments, parameters, inferenceContext);
			for (int i = 0; i < varLength; i++)
				collectedSubstitutes.put(typeVariables[i], new TypeBinding[3][]);
			
			substitutes = new TypeBinding[varLength];
			methodSubstitute = inferFromArgumentTypes(scope, originalMethod, arguments, parameters, collectedSubstitutes, substitutes);
			if (methodSubstitute == null) 
				return null;
			// substitutes may hold null to denote unresolved vars, but null arguments got replaced with respective original variable in param method
			
			// 15.12.2.8 - inferring unresolved type arguments
			if (inferenceContext.hasUnresolvedTypeArgument()) {
				TypeBinding expectedType = null;
				if (methodSubstitute.returnType != TypeBinding.VOID) {
					// if message invocation has expected type

					}
					if (expectedType == null) expectedType = scope.getJavaLangObject(); // assume Object by default
				}
				methodSubstitute = methodSubstitute.inferFromExpectedType(scope, expectedType, inferenceContext);
				if (methodSubstitute == null) 
					return null;
			}

				}
			}
		}

		return methodSubstitute;
	}

	/**
	 * Returns true if any unresolved variable is detected, i.e. any variable is substituted with itself
	 */
	private static boolean hasUnresolvedTypeArgument(TypeBinding[] substitutes) {
		for (int i = 0, varLength = substitutes.length; i <varLength; i++) {
			if (substitutes[i] == null) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Collect argument type mapping, handling varargs
	 */
	private static ParameterizedGenericMethodBinding inferFromArgumentTypes(Scope scope, MethodBinding originalMethod, TypeBinding[] arguments, TypeBinding[] parameters, InferenceContext inferenceContext) {

		if (originalMethod.isVarargs()) {
			int paramLength = parameters.length;

			int argLength = arguments.length;
			// process mandatory arguments
			for (int i = 0; i < minArgLength; i++) {
				parameters[i].collectSubstitutes(scope, arguments[i], inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
				if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
			}
			// process optional arguments
			if (minArgLength < argLength) {

					varargType = ((ArrayBinding)varargType).elementsType(); 
				}
				for (int i = minArgLength; i < argLength; i++) {
					varargType.collectSubstitutes(scope, arguments[i], inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
					if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
				}
			}
		} else {
			int paramLength = parameters.length;
			for (int i = 0; i < paramLength; i++) {
				parameters[i].collectSubstitutes(scope, arguments[i], inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
				if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
			}
		}
		if (inferenceContext.status == InferenceContext.RAW_SUBSTITUTION) {
		int varLength = originalVariables.length;
		substitutes = resolveSubstituteConstraints(scope, originalVariables , substitutes, false/*ignore Ti<:Uk*/, collectedSubstitutes);
		if (substitutes == null) 
			return null; // incompatible
		if (substitutes.length == 0) {
			// raw generic method inferred
			return scope.environment().createParameterizedGenericMethod(originalMethod, (RawTypeBinding)null);
		}
		TypeVariableBinding[] originalVariables = originalMethod.typeVariables;
		if (!resolveSubstituteConstraints(scope, originalVariables , inferenceContext, false/*ignore Ti<:Uk*/)) 
			return null; // impossible substitution

		// apply inferred variable substitutions - replacing unresolved variable with original ones in param method
		TypeBinding[] inferredSustitutes = inferenceContext.substitutes;
		TypeBinding[] actualSubstitutes = inferredSustitutes;
		for (int i = 0, varLength = originalVariables.length; i < varLength; i++) {
			if (inferredSustitutes[i] == null) {
				if (actualSubstitutes == inferredSustitutes) {
					System.arraycopy(inferredSustitutes, 0, actualSubstitutes = new TypeBinding[varLength], 0, i); // clone to replace null with original variable in param method
				}
				actualSubstitutes[i] = originalVariables[i];
			} else if (actualSubstitutes != inferredSustitutes) {
				actualSubstitutes[i] = inferredSustitutes[i];
			}
		}
		ParameterizedGenericMethodBinding paramMethod = scope.environment().createParameterizedGenericMethod(originalMethod, actualSubstitutes);
		return paramMethod;
	}
	
	private static boolean resolveSubstituteConstraints(Scope scope, TypeVariableBinding[] typeVariables, InferenceContext inferenceContext, boolean considerEXTENDSConstraints) {
		TypeBinding[] substitutes = inferenceContext.substitutes;
			// raw generic method inferred
			return Binding.NO_TYPES; // empty array
		}
		int varLength = typeVariables.length;
		
		// check Tj=U constraints
		nextTypeParameter: 
			for (int i = 0; i < varLength; i++) {
				TypeVariableBinding current = typeVariables[i];
				TypeBinding substitute = substitutes[i];
				if (substitute != null) continue nextTypeParameter; // already inferred previously
				TypeBinding [] equalSubstitutes = inferenceContext.getSubstitutes(current, TypeConstants.CONSTRAINT_EQUAL);
				TypeBinding [] equalSubstitutes = variableSubstitutes[CONSTRAINT_EQUAL];
				if (equalSubstitutes != null) {
					nextConstraint:
						for (int j = 0, equalLength = equalSubstitutes.length; j < equalLength; j++) {

						}
				}
			}
		if (inferenceContext.hasUnresolvedTypeArgument()) {
			// check Tj>:U constraints
			nextTypeParameter: 
				for (int i = 0; i < varLength; i++) {
					TypeVariableBinding current = typeVariables[i];
					TypeBinding substitute = substitutes[i];
					if (substitute != null) continue nextTypeParameter; // already inferred previously
					TypeBinding [] bounds = inferenceContext.getSubstitutes(current, TypeConstants.CONSTRAINT_SUPER);
					TypeBinding [] bounds = variableSubstitutes[CONSTRAINT_SUPER];
					if (bounds == null) continue nextTypeParameter;
					TypeBinding mostSpecificSubstitute = scope.lowerUpperBound(bounds);
					if (mostSpecificSubstitute == null) {
						return false; // incompatible
					}
					if (mostSpecificSubstitute != TypeBinding.VOID) {
						substitutes[i] = mostSpecificSubstitute;
					}
				}
		}
		if (considerEXTENDSConstraints && inferenceContext.hasUnresolvedTypeArgument()) {
			// check Tj<:U constraints
			nextTypeParameter: 
				for (int i = 0; i < varLength; i++) {
					TypeVariableBinding current = typeVariables[i];
					TypeBinding substitute = substitutes[i];
					if (substitute != null) continue nextTypeParameter; // already inferred previously
					TypeBinding [] bounds = inferenceContext.getSubstitutes(current, TypeConstants.CONSTRAINT_EXTENDS);
					TypeBinding [] bounds = variableSubstitutes[CONSTRAINT_EXTENDS];
					if (bounds == null) continue nextTypeParameter;
					TypeBinding[] glb = Scope.greaterLowerBound(bounds);
					TypeBinding mostSpecificSubstitute = null;

						}
					} 
		}
		return true;
	}
	
	/**

		}		
	    this.isRaw = true;
	    this.tagBits = originalMethod.tagBits;
		this.isUnchecked = false;
	    this.environment = environment;
		this.modifiers = originalMethod.modifiers;
		this.selector = originalMethod.selector;

	    this.typeArguments = typeArguments;
	    this.isRaw = false;
	    this.tagBits = originalMethod.tagBits;
		this.isUnchecked = false;
	    this.originalMethod = originalMethod;
	    this.parameters = Scope.substitute(this, originalMethod.parameters);
	    this.thrownExceptions = Scope.substitute(this, originalMethod.thrownExceptions);

	 * Given some type expectation, and type variable bounds, perform some inference.
	 * Returns true if still had unresolved type variable at the end of the operation
	 */
	private ParameterizedGenericMethodBinding inferFromExpectedType(Scope scope, TypeBinding expectedType, InferenceContext inferenceContext) {
	    TypeVariableBinding[] originalVariables = this.originalMethod.typeVariables; // immediate parent (could be a parameterized method)
		int varLength = originalVariables.length;
		
		computeSubstitutes: {
		    // infer from expected return type
			if (expectedType != null) {
			    this.returnType.collectSubstitutes(scope, expectedType, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
			    if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
			}
		    // infer from bounds of type parameters
			for (int i = 0; i < varLength; i++) {

				boolean argAlreadyInferred = argument != originalVariable;
				if (originalVariable.firstBound == originalVariable.superclass) {
					TypeBinding substitutedBound = Scope.substitute(this, originalVariable.superclass);
					argument.collectSubstitutes(scope, substitutedBound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
					if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
					// JLS 15.12.2.8 claims reverse inference shouldn't occur, however it improves inference
					// e.g. given: <E extends Object, S extends Collection<E>> S test1(S param)
					//                   invocation: test1(new Vector<String>())    will infer: S=Vector<String>  and with code below: E=String
					if (argAlreadyInferred) {
						substitutedBound.collectSubstitutes(scope, argument, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
						if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
					}
				}
				for (int j = 0, max = originalVariable.superInterfaces.length; j < max; j++) {
					TypeBinding substitutedBound = Scope.substitute(this, originalVariable.superInterfaces[j]);
					argument.collectSubstitutes(scope, substitutedBound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
					if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
					// JLS 15.12.2.8 claims reverse inference shouldn't occur, however it improves inference
					if (argAlreadyInferred) {
						substitutedBound.collectSubstitutes(scope, argument, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
						if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
					}
				}
			}
			if (inferenceContext.status == InferenceContext.RAW_SUBSTITUTION) {
			if (substitutes == null) 
				return null; // incompatible
			if (substitutes.length == 0) {
		    	// raw generic method inferred
		    	this.isRaw = true;
				this.isUnchecked = false;

		    		this.typeArguments[i] = originalVariables[i].upperBound();
		    	}
		    	break computeSubstitutes;
			}		
			if (!resolveSubstituteConstraints(scope, originalVariables, inferenceContext, true/*consider Ti<:Uk*/)) 
				return null; // incompatible
			// this.typeArguments = substitutes; - no op since side effects got performed during #resolveSubstituteConstraints
	    	for (int i = 0; i < varLength; i++) {
	    		TypeBinding substitute = inferenceContext.substitutes[i];
	    		if (substitute != null) {
	    			this.typeArguments[i] = inferenceContext.substitutes[i];
	    		} else {
	    			// remaining unresolved variable are considered to be Object (or their bound actually)
		    		this.typeArguments[i] = originalVariables[i].upperBound();




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

import java.util.Map;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.Constant;

 *   A = F   corresponds to:      F.collectSubstitutes(..., A, ..., 0)
 *   A >> F   corresponds to:   F.collectSubstitutes(..., A, ..., 2)
*/
public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
	
	if ((this.tagBits & TagBits.HasTypeVariable) == 0) return;
	if (actualType == TypeBinding.NULL) return;

		case Binding.ARRAY_TYPE :
	        int actualDim = actualType.dimensions();
	        if (actualDim == this.dimensions) {
			    this.leafComponentType.collectSubstitutes(scope, actualType.leafComponentType(), inferenceContext, constraint);
	        } else if (actualDim > this.dimensions) {
	            ArrayBinding actualReducedType = this.environment.createArrayType(actualType.leafComponentType(), actualDim - this.dimensions);
	            this.leafComponentType.collectSubstitutes(scope, actualReducedType, inferenceContext, constraint);
	        }
			break;
		case Binding.TYPE_PARAMETER :

Lines 10-16 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeBinding.java (-3 / +1 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	11	package org.eclipse.jdt.internal.compiler.lookup;
12		12
13	import java.util.Map;
14	import org.eclipse.jdt.core.compiler.CharOperation;	13	import org.eclipse.jdt.core.compiler.CharOperation;
15	import org.eclipse.jdt.internal.compiler.ast.Wildcard;	14	import org.eclipse.jdt.internal.compiler.ast.Wildcard;
16		15
Lines 112-119 Link Here
112	* A = F corresponds to: F.collectSubstitutes(..., A, ..., 0)	111	* A = F corresponds to: F.collectSubstitutes(..., A, ..., 0)
113	* A >> F corresponds to: F.collectSubstitutes(..., A, ..., 2)	112	* A >> F corresponds to: F.collectSubstitutes(..., A, ..., 2)
114	*/	113	*/
115	public void collectSubstitutes(Scope scope, TypeBinding actualType,	114	public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
116	Map substitutes, int constraint) {
117	// no substitute by default	115	// no substitute by default
118	}	116	}
119		117




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

import java.util.Map;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;

	 *   A = F   corresponds to:      F.collectSubstitutes(..., A, ..., 0)
	 *   A >> F   corresponds to:   F.collectSubstitutes(..., A, ..., 2)
	 */
	public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
		
		//	only infer for type params of the generic method
		if (this.declaringElement != inferenceContext.genericMethod) return;
		
		// cannot infer anything from a null type
		switch (actualType.kind()) {

				variableConstraint =TypeConstants.CONSTRAINT_EXTENDS;
				break;
		}
		inferenceContext.recordSubstitute(this, actualType, variableConstraint);
	    if (variableSubstitutes != null) {
		    insertLoop: {
		    	TypeBinding[] constraintSubstitutes = variableSubstitutes[variableConstraint];
		    	int length;
		    	if (constraintSubstitutes == null) {
		    		length = 0;
		    		constraintSubstitutes = new TypeBinding[1];
		    	} else {
		    		length = constraintSubstitutes.length;
			        for (int i = 0; i < length; i++) {
			        	TypeBinding substitute = constraintSubstitutes[i];
			            if (substitute == actualType) return; // already there
			            if (substitute == null) {
			                constraintSubstitutes[i] = actualType;
			                break insertLoop;
			            }
			        }
			        // no free spot found, need to grow by one
			        System.arraycopy(constraintSubstitutes, 0, constraintSubstitutes = new TypeBinding[length+1], 0, length);
		    	}
		        constraintSubstitutes[length] = actualType;
		        variableSubstitutes[variableConstraint] = constraintSubstitutes;
		    }
	    }
	}
	
	public char[] constantPoolName() { /* java/lang/Object */ 




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

import java.util.Map;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;

	 *   A = F   corresponds to:      F.collectSubstitutes(..., A, ..., 0)
	 *   A >> F   corresponds to:   F.collectSubstitutes(..., A, ..., 2)
	 */
	public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {

		if ((this.tagBits & TagBits.HasTypeVariable) == 0) return;
		if (actualType == TypeBinding.NULL) return;

								case Wildcard.UNBOUND: // A={?} << F={? extends U}  --> 0
									break;
								case Wildcard.EXTENDS: // A={? extends V} << F={? extends U} ---> V << U
									this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
						        	for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
										this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
						        	}									
									break;
								case Wildcard.SUPER: // A={? super V} << F={? extends U} ---> 0
									break;
							}
						} else { // A=V << F={? extends U} ---> V << U
							this.bound.collectSubstitutes(scope, actualType, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
						}
						break;
					case Wildcard.SUPER: // F={? super U}

								case Wildcard.EXTENDS: // A={? extends V} << F={? super U} ---> 0
									break;
								case Wildcard.SUPER: // A={? super V} << F={? super U} ---> 0
									this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
						        	for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
										this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_SUPER);
						        	}									
									break;
							}
						} else { // A=V << F={? super U} ---> V >> U
							this.bound.collectSubstitutes(scope, actualType, inferenceContext, TypeConstants.CONSTRAINT_SUPER);							
						}						
						break;
				}

								case Wildcard.UNBOUND: // A={?} == F={? extends U}  --> 0
									break;
								case Wildcard.EXTENDS: // A={? extends V} == F={? extends U} ---> V == U
									this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
						        	for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
										this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
						        	}											
									break;
								case Wildcard.SUPER: // A={? super V} == F={? extends U} ---> 0

								case Wildcard.EXTENDS: // A={? extends V} == F={? super U} ---> 0
									break;
								case Wildcard.SUPER: // A={? super V} == F={? super U} ---> 0
									this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
						        	for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
										this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
						        	}	
						        	break;
							}

								case Wildcard.UNBOUND: // A={?} >> F={? extends U}  --> 0
									break;
								case Wildcard.EXTENDS: // A={? extends V} >> F={? extends U} ---> V >> U
									this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
						        	for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
										this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_SUPER);
						        	}										
									break;
								case Wildcard.SUPER: // A={? super V} >> F={? extends U} ---> 0

								case Wildcard.EXTENDS: // A={? extends V} >> F={? super U} ---> 0
									break;
								case Wildcard.SUPER: // A={? super V} >> F={? super U} ---> V >> U
									this.bound.collectSubstitutes(scope, actualWildcard.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
						        	for (int i = 0, length = actualWildcard.otherBounds == null ? 0 : actualWildcard.otherBounds.length; i < length; i++) {
										this.bound.collectSubstitutes(scope, actualWildcard.otherBounds[i], inferenceContext, TypeConstants.CONSTRAINT_SUPER);
						        	}	
						        	break;
							}




	// for null reference analysis
	public static final int IsNonNull = Bit18;
	
	
	// constants used when checking invocation arguments
	public static final int INVOCATION_ARGUMENT_OK = 0;
	public static final int INVOCATION_ARGUMENT_UNCHECKED = 1;
	public static final int INVOCATION_ARGUMENT_WILDCARD = 2;
	
	public ASTNode() {

		super();
	}
	private static int checkInvocationArgument(BlockScope scope, Expression argument, TypeBinding parameterType, TypeBinding argumentType, TypeBinding originalParameterType) {
		argument.computeConversion(scope, parameterType, argumentType);

		if (argumentType != TypeBinding.NULL && parameterType.isWildcard()) {
			WildcardBinding wildcard = (WildcardBinding) parameterType;
			if (wildcard.boundKind != Wildcard.SUPER && wildcard.otherBounds == null) // lub wildcards are tolerated
		    	return INVOCATION_ARGUMENT_WILDCARD;
		}
		TypeBinding checkedParameterType = originalParameterType == null ? parameterType : originalParameterType;
		if (argumentType != checkedParameterType && argumentType.needsUncheckedConversion(checkedParameterType)) {
			scope.problemReporter().unsafeTypeConversion(argument, argumentType, checkedParameterType);
			return INVOCATION_ARGUMENT_UNCHECKED;
			}
		}
		return INVOCATION_ARGUMENT_OK;
	}
	public static void checkInvocationArguments(BlockScope scope, Expression receiver, TypeBinding receiverType, MethodBinding method, Expression[] arguments, TypeBinding[] argumentTypes, boolean argsContainCast, InvocationSite invocationSite) {
		boolean unsafeWildcardInvocation = false;
		TypeBinding[] params = method.parameters;
		int paramLength = params.length;
		boolean isRawMemberInvocation = !method.isStatic() 

				}
			}
		}
		int invocationStatus = INVOCATION_ARGUMENT_OK;
		if (arguments == null) {
			if (method.isVarargs()) {
				TypeBinding parameterType = ((ArrayBinding) params[paramLength-1]).elementsType(); // no element was supplied for vararg parameter
		    	if (!parameterType.isReifiable()) {
				    scope.problemReporter().unsafeGenericArrayForVarargs(parameterType, (ASTNode)invocationSite);					
		    	}				
			}
		} else {
			if (method.isVarargs()) {
				// 4 possibilities exist for a call to the vararg method foo(int i, long ... value) : foo(1), foo(1, 2), foo(1, 2, 3, 4) & foo(1, new long[] {1, 2})
				int lastIndex = paramLength - 1;
				for (int i = 0; i < lastIndex; i++) {
					TypeBinding originalRawParam = rawOriginalGenericMethod == null ? null : rawOriginalGenericMethod.parameters[i];
					invocationStatus |= checkInvocationArgument(scope, arguments[i], params[i] , argumentTypes[i], originalRawParam);
					    unsafeWildcardInvocation = true;
				    }
				}
			   int argLength = arguments.length;
			   if (lastIndex < argLength) { // vararg argument was provided

						originalRawParam = rawOriginalGenericMethod == null ? null : ((ArrayBinding)rawOriginalGenericMethod.parameters[lastIndex]).elementsType();
				    }
					for (int i = lastIndex; i < argLength; i++) {
						invocationStatus |= checkInvocationArgument(scope, arguments[i], parameterType, argumentTypes[i], originalRawParam);
						    unsafeWildcardInvocation = true;
					}
				}
	

			} else {
				for (int i = 0; i < paramLength; i++) {
					TypeBinding originalRawParam = rawOriginalGenericMethod == null ? null : rawOriginalGenericMethod.parameters[i];
					invocationStatus |= checkInvocationArgument(scope, arguments[i], params[i], argumentTypes[i], originalRawParam);
					    unsafeWildcardInvocation = true;
				}
			}
			if (argsContainCast) {
				CastExpression.checkNeedForArgumentCasts(scope, receiver, receiverType, method, arguments, argumentTypes, invocationSite);
			}
		}
		if ((invocationStatus & INVOCATION_ARGUMENT_WILDCARD) != 0) {
		    scope.problemReporter().wildcardInvocation((ASTNode)invocationSite, receiverType, method, argumentTypes);
		} else if (!method.isStatic() && !receiverType.isUnboundWildcard() && method.declaringClass.isRawType() && method.hasSubstitutedParameters()) {
		    scope.problemReporter().unsafeRawInvocation((ASTNode)invocationSite, method);




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;

/**
 * Context used during type inference for a generic method invocation
 */
public class InferenceContext {
	
	private TypeBinding[][][] collectedSubstitutes;
	MethodBinding genericMethod;
	int depth;
	int status;
	TypeBinding[] substitutes;
	final static int FAILED = 1;
	final static int RAW_SUBSTITUTION = 2;
	
public InferenceContext(MethodBinding genericMethod) {
	this.genericMethod = genericMethod;
	TypeVariableBinding[] typeVariables = genericMethod.typeVariables;
	int varLength = typeVariables.length;
	this.collectedSubstitutes = new TypeBinding[varLength][3][];
	this.substitutes = new TypeBinding[varLength];
}

public boolean checkRawSubstitution() {
	// only at first level, during inference from arguments
	if (depth > 0) return false;
//	if (this.argumentIndex < 0 || this.depth != 0) {
//		return false;
//	}
	this.status = RAW_SUBSTITUTION;
	return true;
}		

public TypeBinding[] getSubstitutes(TypeVariableBinding typeVariable, int constraint) {
	return this.collectedSubstitutes[typeVariable.rank][constraint];
}

/**
 * Returns true if any unresolved variable is detected, i.e. any variable is substituted with itself
 */
public boolean hasUnresolvedTypeArgument() {
	for (int i = 0, varLength = this.substitutes.length; i <varLength; i++) {
		if (this.substitutes[i] == null) {
			return true;
		}
	}
	return false;
}		

public void recordSubstitute(TypeVariableBinding typeVariable, TypeBinding actualType, int constraint) {
    TypeBinding[][] variableSubstitutes = this.collectedSubstitutes[typeVariable.rank];
    insertLoop: {
    	TypeBinding[] constraintSubstitutes = variableSubstitutes[constraint];
    	int length;
    	if (constraintSubstitutes == null) {
    		length = 0;
    		constraintSubstitutes = new TypeBinding[1];
    	} else {
    		length = constraintSubstitutes.length;
	        for (int i = 0; i < length; i++) {
	        	TypeBinding substitute = constraintSubstitutes[i];
	            if (substitute == actualType) return; // already there
	            if (substitute == null) {
	                constraintSubstitutes[i] = actualType;
	                break insertLoop;
	            }
	        }
	        // no free spot found, need to grow by one
	        System.arraycopy(constraintSubstitutes, 0, constraintSubstitutes = new TypeBinding[length+1], 0, length);
    	}
        constraintSubstitutes[length] = actualType;
        variableSubstitutes[constraint] = constraintSubstitutes;
    }
}
public String toString() {
	StringBuffer buffer = new StringBuffer(20);
	buffer.append("InferenceContex for ");//$NON-NLS-1$
	for (int i = 0, length = this.genericMethod.typeVariables.length; i < length; i++) {
		buffer.append(this.genericMethod.typeVariables[i]);
	}
	buffer.append(this.genericMethod); 
	buffer.append("\n\t[status=");//$NON-NLS-1$
	switch(this.status) {
		case 0 :
			buffer.append("ok]");//$NON-NLS-1$
			break;
		case FAILED :
			buffer.append("failed]");//$NON-NLS-1$
			break;
		case RAW_SUBSTITUTION :
			buffer.append("raw-subst]");//$NON-NLS-1$
			break;
	}
	buffer.append("[depth=").append(this.depth).append(']'); //$NON-NLS-1$
	buffer.append("\n\t[collected={");//$NON-NLS-1$
	for (int i = 0, length = this.collectedSubstitutes == null ? 0 : this.collectedSubstitutes.length; i < length; i++) {
		TypeBinding[][] collected = this.collectedSubstitutes[i];
		for (int j = TypeConstants.CONSTRAINT_EQUAL; j < TypeConstants.CONSTRAINT_SUPER; j++) {
			TypeBinding[] constraintCollected = collected[j];
			if (constraintCollected != null) {
				for (int k = 0, clength = constraintCollected.length; k < clength; k++) {
					buffer.append("\n\t\t").append(this.genericMethod.typeVariables[i].sourceName); //$NON-NLS-1$
					switch (j) {
						case TypeConstants.CONSTRAINT_EQUAL :
							buffer.append("="); //$NON-NLS-1$
							break;
						case TypeConstants.CONSTRAINT_EXTENDS :
							buffer.append("<:"); //$NON-NLS-1$
							break;
						case TypeConstants.CONSTRAINT_SUPER :
							buffer.append(">:"); //$NON-NLS-1$
							break;
					}
					buffer.append(constraintCollected[k]);
				}
			}
		}
	}
	buffer.append("}]");//$NON-NLS-1$
	buffer.append("\n\t[inferred=");//$NON-NLS-1$
	int count = 0;
	for (int i = 0, length = this.substitutes == null ? 0 : this.substitutes.length; i < length; i++) {
		if (this.substitutes[i] == null) continue;
		count++;
		buffer.append('{').append(this.genericMethod.typeVariables[i].sourceName);
		buffer.append("=").append(this.substitutes[i]).append('}'); //$NON-NLS-1$
	}
	if (count == 0) buffer.append("{}"); //$NON-NLS-1$
	buffer.append(']');
	return buffer.toString();
}
}




	}		
	
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=78467 
	public void testONLY_0412() {
		this.runNegativeTest(
			new String[] {
				"X.java",

				"   Zork z;\n" +
				"}",
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 15)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n");	
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=78467 - variation
	public void testONLY_0412a() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"import java.util.*;\n" +
				"public class X {\n" + 
				"\n" + 
				"    public static <T> T first(T... args) {\n" + 
				"        return args[0];\n" + 
				"    }\n" + 
				"    \n" + 
				"    public static void main(String[] args) {\n" + 
				"    	if (false) { \n" + 
				"    		List<String> ls = first(); \n" + 
				"    		int i; \n" + 
				"    		i++; \n" + 
				"    	}\n" + 
				"        System.out.println(first(\"SUCCESS\", \"List\"));\n" + 
				"    }\n" + 
				"   Zork z;\n" +
				"}",
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 10)\n" + 
			"	List<String> ls = first(); \n" + 
			"	                  ^^^^^^^\n" + 
			"Type safety : A generic array of List<String> is created for a varargs parameter\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 16)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n");	
	}
	
	public void test0413() {

			"public class GenericsProblem {\n" + 
			"	public <T> void test(T val) {\n" + 
			"		GenericsProblem gp = new GenericsProblem();\n" + 
			"		// this is fine with both\n" + 
			"		Class<? extends GenericsProblem> cl2 = gp.getClass();\n" + 
			"		// This fails on Sun\'s compiler\n" + 
			"		Class<? extends T> cl = val.getClass();\n" + 
			"	}\n" + 
			"}\n",
		},
		"----------\n" + 
		"1. ERROR in GenericsProblem.java (at line 5)\n" + 
		"	Class<? extends T> cl = val.getClass();\n" + 
		"	                        ^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Class<capture-of ? extends Object> to Class<? extends T>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061
public void test1008() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" + 
			"	void foo(L l, C<? extends X> c) {\n" + 
			"		X x = bar(l, c);\n" + 
			"	}\n" + 
			"	<T> T bar(L<T> l, C<? extends T> c) { \n" + 
			"		return null;\n" + 
			"	}	\n" + 
			"}\n" + 
			"class C<E> {}\n" + 
			"class L<E> {}\n" + 
			"\n" + 
			"\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 2)\r\n" + 
		"	void foo(L l, C<? extends X> c) {\r\n" + 
		"	         ^\n" + 
		"L is a raw type. References to generic type L<E> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 3)\r\n" + 
		"	X x = bar(l, c);\r\n" + 
		"	      ^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar(L, C) of the generic method bar(L<T>, C<? extends T>) of type X\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 3)\r\n" + 
		"	X x = bar(l, c);\r\n" + 
		"	      ^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Object to X\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 3)\r\n" + 
		"	X x = bar(l, c);\r\n" + 
		"	          ^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<T>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1009() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.Map;\n" + 
			"public class X {\n" + 
			"\n" + 
			"	void foo(Map<String,Map> map) {\n" + 
			"		bar(map);\n" + 
			"	}\n" + 
			"	<U,V> void bar(Map<U,Map<U,V>> map) {\n" + 
			"	}\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\n" + 
		"	void foo(Map<String,Map> map) {\n" + 
		"	                    ^^^\n" + 
		"Map is a raw type. References to generic type Map<K,V> should be parameterized\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 5)\n" + 
		"	bar(map);\n" + 
		"	^^^\n" + 
		"The method bar(Map<U,Map<U,V>>) in the type X is not applicable for the arguments (Map<String,Map>)\n" + 
		"----------\n");
}	
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1010() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.Map;\n" + 
			"public class X {\n" + 
			"\n" + 
			"	void foo(Map<String,Map> map) {\n" + 
			"		bar(map);\n" + 
			"	}\n" + 
			"	<U,V> void bar(Map<U,? extends Map<U,V>> map) {\n" + 
			"	}\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\n" + 
		"	void foo(Map<String,Map> map) {\n" + 
		"	                    ^^^\n" + 
		"Map is a raw type. References to generic type Map<K,V> should be parameterized\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 5)\n" + 
		"	bar(map);\n" + 
		"	^^^\n" + 
		"The method bar(Map<U,? extends Map<U,V>>) in the type X is not applicable for the arguments (Map<String,Map>)\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1011() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.*;\n" + 
			"public class X {\n" + 
			"	void foo(HashMap map, String s, Map<String,String> map2) {\n" + 
			"		bar(map, s, map2); //1\n" + 
			"		bar(map2, s, map2); //2\n" + 
			"		bar2(map, s, map2); //3\n" + 
			"		bar3(map, s, map2); //4\n" + 
			"	}\n" + 
			"	<U> void bar(Map<U,U> map, U u, Map<U,U> map2) {}\n" + 
			"	void bar2(Map<String,String> map, String s, Map<String,String> map2) {}\n" + 
			"	<U> void bar3(Map<String,String> map, U s, Map<U,U> map2) {}\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	void foo(HashMap map, String s, Map<String,String> map2) {\n" + 
		"	         ^^^^^^^\n" + 
		"HashMap is a raw type. References to generic type HashMap<K,V> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 4)\n" + 
		"	bar(map, s, map2); //1\n" + 
		"	^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar(Map, Object, Map) of the generic method bar(Map<U,U>, U, Map<U,U>) of type X\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 4)\n" + 
		"	bar(map, s, map2); //1\n" + 
		"	    ^^^\n" + 
		"Type safety: The expression of type HashMap needs unchecked conversion to conform to Map<U,U>\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 6)\n" + 
		"	bar2(map, s, map2); //3\n" + 
		"	     ^^^\n" + 
		"Type safety: The expression of type HashMap needs unchecked conversion to conform to Map<String,String>\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 7)\n" + 
		"	bar3(map, s, map2); //4\n" + 
		"	     ^^^\n" + 
		"Type safety: The expression of type HashMap needs unchecked conversion to conform to Map<String,String>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1012() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public class X {\n" + 
			"	void foo(L l, C<X> c) {\n" + 
			"		X x = bar1(l, c);\n" + 
			"		L<X> lx = bar2(l, c);\n" + 
			"		C<X> cx = bar3(l, c);\n" + 
			"	}\n" + 
			"	<T> T bar1(L<T> l, C<T> c) {\n" + 
			"		return null;\n" + 
			"	}\n" + 
			"	<T> L<T> bar2(L<T> l, C<T> c) {\n" + 
			"		return null;\n" + 
			"	}\n" + 
			"	<T> C<T> bar3(L<T> l, C<T> c) {\n" + 
			"		return null;\n" + 
			"	}\n" + 
			"}\n" + 
			"\n" + 
			"class C<E> {}\n" + 
			"class L<E> {}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 2)\r\n" + 
		"	void foo(L l, C<X> c) {\r\n" + 
		"	         ^\n" + 
		"L is a raw type. References to generic type L<E> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 3)\r\n" + 
		"	X x = bar1(l, c);\r\n" + 
		"	      ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar1(L, C) of the generic method bar1(L<T>, C<T>) of type X\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 3)\r\n" + 
		"	X x = bar1(l, c);\r\n" + 
		"	      ^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Object to X\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 3)\r\n" + 
		"	X x = bar1(l, c);\r\n" + 
		"	           ^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<T>\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 4)\r\n" + 
		"	L<X> lx = bar2(l, c);\r\n" + 
		"	          ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar2(L, C) of the generic method bar2(L<T>, C<T>) of type X\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 4)\r\n" + 
		"	L<X> lx = bar2(l, c);\r\n" + 
		"	          ^^^^^^^^^^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<X>\n" + 
		"----------\n" + 
		"7. WARNING in X.java (at line 4)\r\n" + 
		"	L<X> lx = bar2(l, c);\r\n" + 
		"	               ^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<T>\n" + 
		"----------\n" + 
		"8. WARNING in X.java (at line 5)\r\n" + 
		"	C<X> cx = bar3(l, c);\r\n" + 
		"	          ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar3(L, C) of the generic method bar3(L<T>, C<T>) of type X\n" + 
		"----------\n" + 
		"9. WARNING in X.java (at line 5)\r\n" + 
		"	C<X> cx = bar3(l, c);\r\n" + 
		"	          ^^^^^^^^^^\n" + 
		"Type safety: The expression of type C needs unchecked conversion to conform to C<X>\n" + 
		"----------\n" + 
		"10. WARNING in X.java (at line 5)\r\n" + 
		"	C<X> cx = bar3(l, c);\r\n" + 
		"	               ^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<T>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1013() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.*;\n" + 
			"\n" + 
			"public class X {\n" + 
			"	public static void main(String[] args) {\n" + 
			"		List<String> ls = new ArrayList<String>();\n" + 
			"		ls.add(\"foo\");\n" + 
			"		List<X> lx = new ArrayList<X>();\n" + 
			"		lx.add(new X());\n" + 
			"		new X().foo(ls, lx);\n" + 
			"	}\n" + 
			"	void done() {\n" + 
			"		System.out.println(\"[done]\");\n" + 
			"	}\n" + 
			"	void foo(List l1, List<X> l2) {\n" + 
			"		X x = bar1(l1, l2);\n" + 
			"		x.done();\n" + 
			"		List<X> lx = bar2(l1, l2);\n" + 
			"		lx.get(0).done();\n" + 
			"	}\n" + 
			"	<T> T bar1(List<T> l1, List<T> l2) {\n" + 
			"		return l1.get(0);\n" + 
			"	}\n" + 
			"	<T> List<T> bar2(List<T> l1, List<T> l2) {\n" + 
			"		return l1;\n" + 
			"	}\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 14)\r\n" + 
		"	void foo(List l1, List<X> l2) {\r\n" + 
		"	         ^^^^\n" + 
		"List is a raw type. References to generic type List<E> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 15)\r\n" + 
		"	X x = bar1(l1, l2);\r\n" + 
		"	      ^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar1(List, List) of the generic method bar1(List<T>, List<T>) of type X\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 15)\r\n" + 
		"	X x = bar1(l1, l2);\r\n" + 
		"	      ^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Object to X\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 15)\r\n" + 
		"	X x = bar1(l1, l2);\r\n" + 
		"	           ^^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<T>\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 17)\r\n" + 
		"	List<X> lx = bar2(l1, l2);\r\n" + 
		"	             ^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar2(List, List) of the generic method bar2(List<T>, List<T>) of type X\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 17)\r\n" + 
		"	List<X> lx = bar2(l1, l2);\r\n" + 
		"	             ^^^^^^^^^^^^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<X>\n" + 
		"----------\n" + 
		"7. WARNING in X.java (at line 17)\r\n" + 
		"	List<X> lx = bar2(l1, l2);\r\n" + 
		"	                  ^^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<T>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1014() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.*;\n" + 
			"\n" + 
			"public class X {\n" + 
			"	void foo1(List l, List<String> ls) {\n" + 
			"		Set<Map.Entry<String,String>> mss1 = bar(l, ls).entrySet();\n" + 
			"		String s = bar(l, ls).entrySet();\n" + 
			"	}\n" + 
			"	<U,V> Map<U,V> bar(List<U> lu, List<V> lv) { return null; }\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\n" + 
		"	void foo1(List l, List<String> ls) {\n" + 
		"	          ^^^^\n" + 
		"List is a raw type. References to generic type List<E> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 5)\n" + 
		"	Set<Map.Entry<String,String>> mss1 = bar(l, ls).entrySet();\n" + 
		"	                                     ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar(List, List) of the generic method bar(List<U>, List<V>) of type X\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 5)\n" + 
		"	Set<Map.Entry<String,String>> mss1 = bar(l, ls).entrySet();\n" + 
		"	                                     ^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: The expression of type Set needs unchecked conversion to conform to Set<Map.Entry<String,String>>\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 5)\n" + 
		"	Set<Map.Entry<String,String>> mss1 = bar(l, ls).entrySet();\n" + 
		"	                                         ^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<U>\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 6)\n" + 
		"	String s = bar(l, ls).entrySet();\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar(List, List) of the generic method bar(List<U>, List<V>) of type X\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 6)\n" + 
		"	String s = bar(l, ls).entrySet();\n" + 
		"	           ^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Set to String\n" + 
		"----------\n" + 
		"7. WARNING in X.java (at line 6)\n" + 
		"	String s = bar(l, ls).entrySet();\n" + 
		"	               ^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<U>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1015() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.*;\n" + 
			"public class X {\n" + 
			"	void foo1(List l, List<String> ls) {\n" + 
			"		List<String> ls1 = bar(l, ls);\n" + 
			"		String s = bar(l, ls);\n" + 
			"	}\n" + 
			"	<U,V> List<V> bar(List<U> lu, List<V> lv) { return null; }\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 3)\n" + 
		"	void foo1(List l, List<String> ls) {\n" + 
		"	          ^^^^\n" + 
		"List is a raw type. References to generic type List<E> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 4)\n" + 
		"	List<String> ls1 = bar(l, ls);\n" + 
		"	                   ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar(List, List) of the generic method bar(List<U>, List<V>) of type X\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 4)\n" + 
		"	List<String> ls1 = bar(l, ls);\n" + 
		"	                   ^^^^^^^^^^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<String>\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 4)\n" + 
		"	List<String> ls1 = bar(l, ls);\n" + 
		"	                       ^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<U>\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 5)\n" + 
		"	String s = bar(l, ls);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar(List, List) of the generic method bar(List<U>, List<V>) of type X\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 5)\n" + 
		"	String s = bar(l, ls);\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from List to String\n" + 
		"----------\n" + 
		"7. WARNING in X.java (at line 5)\n" + 
		"	String s = bar(l, ls);\n" + 
		"	               ^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<U>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1016() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"import java.util.*;\n" + 
			"public class X {\n" + 
			"	void foo1() {\n" + 
			"		List ls1 = bar(null);\n" + 
			"		List<String> ls2 = bar(null);\n" + 
			"		String s = bar(null);\n" + 
			"	}\n" + 
			"	<U> List<U> bar(List<U> lu) { return null; }\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 4)\n" + 
		"	List ls1 = bar(null);\n" + 
		"	^^^^\n" + 
		"List is a raw type. References to generic type List<E> should be parameterized\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 6)\n" + 
		"	String s = bar(null);\n" + 
		"	           ^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from List<Object> to String\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1017() {
	this.runNegativeTest(
		new String[] {
			"SortedList.java",
			"import java.util.*;\n" + 
			"\n" + 
			"public class SortedList<E extends Comparable> extends LinkedList<E>\n" + 
			"{\n" + 
			"    public boolean add(E e){\n" + 
			"      int index = Collections.binarySearch(this,e);\n" + 
			"      if (index<0)\n" + 
			"      super.add(-index-1,e);\n" + 
			"      return true;\n" + 
			"  }\n" + 
			"}", // =================
		},
		"----------\n" + 
		"1. WARNING in SortedList.java (at line 3)\n" + 
		"	public class SortedList<E extends Comparable> extends LinkedList<E>\n" + 
		"	             ^^^^^^^^^^\n" + 
		"The serializable class SortedList does not declare a static final serialVersionUID field of type long\n" + 
		"----------\n" + 
		"2. WARNING in SortedList.java (at line 3)\n" + 
		"	public class SortedList<E extends Comparable> extends LinkedList<E>\n" + 
		"	                                  ^^^^^^^^^^\n" + 
		"Comparable is a raw type. References to generic type Comparable<T> should be parameterized\n" + 
		"----------\n" + 
		"3. WARNING in SortedList.java (at line 5)\n" + 
		"	public boolean add(E e){\n" + 
		"	               ^^^^^^^^\n" + 
		"The method add(E) of type SortedList<E> should be tagged with @Override since it actually overrides a superclass method\n" + 
		"----------\n" + 
		"4. ERROR in SortedList.java (at line 6)\n" + 
		"	int index = Collections.binarySearch(this,e);\n" + 
		"	                        ^^^^^^^^^^^^\n" + 
		"The method binarySearch(List<? extends Comparable<? super T>>, T) in the type Collections is not applicable for the arguments (SortedList<E>, E)\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation
public void test1018() {
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X<U,V> {\n" + 
			"\n" + 
			"	void foo(U u) {\n" + 
			"		bar(u, new Exception());\n" + 
			"	}\n" + 
			"	<T extends Exception> T bar(U u, T t) { return null; }\n" + 
			"}", // =================
		},
		"");
}
}

Return to bug 111086

Lines 10-16 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedTypeBinding.java (-11 / +13 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;	11	package org.eclipse.jdt.internal.compiler.lookup;
12		12
13	import java.util.Map;
14	import org.eclipse.jdt.core.compiler.CharOperation;	13	import org.eclipse.jdt.core.compiler.CharOperation;
15	import org.eclipse.jdt.internal.compiler.ast.TypeReference;	14	import org.eclipse.jdt.internal.compiler.ast.TypeReference;
16	import org.eclipse.jdt.internal.compiler.ast.Wildcard;	15	import org.eclipse.jdt.internal.compiler.ast.Wildcard;
Lines 120-126 Link Here
120	* A = F corresponds to: F.collectSubstitutes(..., A, ..., 0)	119	* A = F corresponds to: F.collectSubstitutes(..., A, ..., 0)
121	* A >> F corresponds to: F.collectSubstitutes(..., A, ..., 2)	120	* A >> F corresponds to: F.collectSubstitutes(..., A, ..., 2)
122	*/	121	*/
123	public void collectSubstitutes(Scope scope, TypeBinding actualType, Map substitutes, int constraint) {	122	public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
124		123
125	if ((this.tagBits & TagBits.HasTypeVariable) == 0) return;	124	if ((this.tagBits & TagBits.HasTypeVariable) == 0) return;
126	if (actualType == TypeBinding.NULL) return;	125	if (actualType == TypeBinding.NULL) return;
Lines 144-150 Link Here
144	// collect through enclosing type	143	// collect through enclosing type
145	ReferenceBinding formalEnclosingType = formalEquivalent.enclosingType();	144	ReferenceBinding formalEnclosingType = formalEquivalent.enclosingType();
146	if (formalEnclosingType != null) {	145	if (formalEnclosingType != null) {
147	formalEnclosingType.collectSubstitutes(scope, actualEquivalent.enclosingType(), substitutes, constraint);	146	formalEnclosingType.collectSubstitutes(scope, actualEquivalent.enclosingType(), inferenceContext, constraint);
148	}	147	}
149	// collect through type arguments	148	// collect through type arguments
150	if (this.arguments == null) return;	149	if (this.arguments == null) return;
Lines 157-163 Link Here
157	formalArguments = ((ParameterizedTypeBinding)formalEquivalent).arguments;	156	formalArguments = ((ParameterizedTypeBinding)formalEquivalent).arguments;
158	break;	157	break;
159	case Binding.RAW_TYPE :	158	case Binding.RAW_TYPE :
160	substitutes.clear(); // clear all variables to indicate raw generic method in the end	159	if (!inferenceContext.checkRawSubstitution()) {
		160	inferenceContext.status = InferenceContext.FAILED; // marker for impossible inference
		161	}
161	return;	162	return;
162	default :	163	default :
163	return;	164	return;
Lines 171-189 Link Here
171	actualArguments = ((ParameterizedTypeBinding)actualEquivalent).arguments;	172	actualArguments = ((ParameterizedTypeBinding)actualEquivalent).arguments;
172	break;	173	break;
173	case Binding.RAW_TYPE :	174	case Binding.RAW_TYPE :
174	substitutes.clear(); // clear all variables to indicate raw generic method in the end	175	if (!inferenceContext.checkRawSubstitution()) {
175	if (constraint == TypeConstants.CONSTRAINT_EQUAL) {	176	inferenceContext.status = InferenceContext.FAILED; // marker for impossible inference
176	substitutes.put(TypeBinding.VOID, Binding.NO_TYPES); // marker for impossible inference
177	}	177	}
178	return;	178	return;
179	default :	179	default :
180	return;	180	return;
181	}	181	}
		182	inferenceContext.depth++;
182	for (int i = 0, length = formalArguments.length; i < length; i++) {	183	for (int i = 0, length = formalArguments.length; i < length; i++) {
183	TypeBinding formalArgument = formalArguments[i];	184	TypeBinding formalArgument = formalArguments[i];
184	TypeBinding actualArgument = actualArguments[i];	185	TypeBinding actualArgument = actualArguments[i];
185	if (formalArgument.isWildcard()) {	186	if (formalArgument.isWildcard()) {
186	formalArgument.collectSubstitutes(scope, actualArgument, substitutes, constraint);	187	formalArgument.collectSubstitutes(scope, actualArgument, inferenceContext, constraint);
187	continue;	188	continue;
188	} else if (actualArgument.isWildcard()){	189	} else if (actualArgument.isWildcard()){
189	WildcardBinding actualWildcardArgument = (WildcardBinding) actualArgument;	190	WildcardBinding actualWildcardArgument = (WildcardBinding) actualArgument;
Lines 191-200 Link Here
191	if (constraint == TypeConstants.CONSTRAINT_SUPER) { // JLS 15.12.7, p.459	192	if (constraint == TypeConstants.CONSTRAINT_SUPER) { // JLS 15.12.7, p.459
192	switch(actualWildcardArgument.boundKind) {	193	switch(actualWildcardArgument.boundKind) {
193	case Wildcard.EXTENDS :	194	case Wildcard.EXTENDS :
194	formalArgument.collectSubstitutes(scope, actualWildcardArgument.bound, substitutes, TypeConstants.CONSTRAINT_SUPER);	195	formalArgument.collectSubstitutes(scope, actualWildcardArgument.bound, inferenceContext, TypeConstants.CONSTRAINT_SUPER);
195	continue;	196	continue;
196	case Wildcard.SUPER :	197	case Wildcard.SUPER :
197	formalArgument.collectSubstitutes(scope, actualWildcardArgument.bound, substitutes, TypeConstants.CONSTRAINT_EXTENDS);	198	formalArgument.collectSubstitutes(scope, actualWildcardArgument.bound, inferenceContext, TypeConstants.CONSTRAINT_EXTENDS);
198	continue;	199	continue;
199	default :	200	default :
200	continue; // cannot infer anything further from unbound wildcard	201	continue; // cannot infer anything further from unbound wildcard
Lines 205-212 Link Here
205	}	206	}
206	}	207	}
207	// by default, use EQUAL constraint	208	// by default, use EQUAL constraint
208	formalArgument.collectSubstitutes(scope, actualArgument, substitutes, TypeConstants.CONSTRAINT_EQUAL);	209	formalArgument.collectSubstitutes(scope, actualArgument, inferenceContext, TypeConstants.CONSTRAINT_EQUAL);
209	}	210	}
		211	inferenceContext.depth--;
210	}	212	}
211		213
212	/**	214	/**

Lines 172-199 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ASTNode.java (-17 / +25 lines)
172	// for null reference analysis	172	// for null reference analysis
173	public static final int IsNonNull = Bit18;	173	public static final int IsNonNull = Bit18;
174		174
		175
		176	// constants used when checking invocation arguments
		177	public static final int INVOCATION_ARGUMENT_OK = 0;
		178	public static final int INVOCATION_ARGUMENT_UNCHECKED = 1;
		179	public static final int INVOCATION_ARGUMENT_WILDCARD = 2;
		180
175	public ASTNode() {	181	public ASTNode() {
176		182
177	super();	183	super();
178	}	184	}
179	private static boolean checkInvocationArgument(BlockScope scope, Expression argument, TypeBinding parameterType, TypeBinding argumentType, TypeBinding originalParameterType) {	185	private static int checkInvocationArgument(BlockScope scope, Expression argument, TypeBinding parameterType, TypeBinding argumentType, TypeBinding originalParameterType) {
180	argument.computeConversion(scope, parameterType, argumentType);	186	argument.computeConversion(scope, parameterType, argumentType);
181		187
182	if (argumentType != TypeBinding.NULL && parameterType.isWildcard()) {	188	if (argumentType != TypeBinding.NULL && parameterType.isWildcard()) {
183	WildcardBinding wildcard = (WildcardBinding) parameterType;	189	WildcardBinding wildcard = (WildcardBinding) parameterType;
184	if (wildcard.boundKind != Wildcard.SUPER && wildcard.otherBounds == null) // lub wildcards are tolerated	190	if (wildcard.boundKind != Wildcard.SUPER && wildcard.otherBounds == null) // lub wildcards are tolerated
185	return true; // unsafeWildcardInvocation	191	return INVOCATION_ARGUMENT_WILDCARD;
186	}	192	}
187	TypeBinding checkedParameterType = originalParameterType == null ? parameterType : originalParameterType;	193	TypeBinding checkedParameterType = originalParameterType == null ? parameterType : originalParameterType;
188	if (argumentType != checkedParameterType) {	194	if (argumentType != checkedParameterType && argumentType.needsUncheckedConversion(checkedParameterType)) {
189	if (argumentType.needsUncheckedConversion(checkedParameterType)) {	195	scope.problemReporter().unsafeTypeConversion(argument, argumentType, checkedParameterType);
190	scope.problemReporter().unsafeTypeConversion(argument, argumentType, checkedParameterType);	196	return INVOCATION_ARGUMENT_UNCHECKED;
191	}
192	}	197	}
193	return false;	198	return INVOCATION_ARGUMENT_OK;
194	}	199	}
195	public static void checkInvocationArguments(BlockScope scope, Expression receiver, TypeBinding receiverType, MethodBinding method, Expression[] arguments, TypeBinding[] argumentTypes, boolean argsContainCast, InvocationSite invocationSite) {	200	public static void checkInvocationArguments(BlockScope scope, Expression receiver, TypeBinding receiverType, MethodBinding method, Expression[] arguments, TypeBinding[] argumentTypes, boolean argsContainCast, InvocationSite invocationSite) {
196	boolean unsafeWildcardInvocation = false;
197	TypeBinding[] params = method.parameters;	201	TypeBinding[] params = method.parameters;
198	int paramLength = params.length;	202	int paramLength = params.length;
199	boolean isRawMemberInvocation = !method.isStatic()	203	boolean isRawMemberInvocation = !method.isStatic()
Lines 210-224 Link Here
210	}	214	}
211	}	215	}
212	}	216	}
213	if (arguments != null) {	217	int invocationStatus = INVOCATION_ARGUMENT_OK;
		218	if (arguments == null) {
		219	if (method.isVarargs()) {
		220	TypeBinding parameterType = ((ArrayBinding) params[paramLength-1]).elementsType(); // no element was supplied for vararg parameter
		221	if (!parameterType.isReifiable()) {
		222	scope.problemReporter().unsafeGenericArrayForVarargs(parameterType, (ASTNode)invocationSite);
		223	}
		224	}
		225	} else {
214	if (method.isVarargs()) {	226	if (method.isVarargs()) {
215	// 4 possibilities exist for a call to the vararg method foo(int i, long ... value) : foo(1), foo(1, 2), foo(1, 2, 3, 4) & foo(1, new long[] {1, 2})	227	// 4 possibilities exist for a call to the vararg method foo(int i, long ... value) : foo(1), foo(1, 2), foo(1, 2, 3, 4) & foo(1, new long[] {1, 2})
216	int lastIndex = paramLength - 1;	228	int lastIndex = paramLength - 1;
217	for (int i = 0; i < lastIndex; i++) {	229	for (int i = 0; i < lastIndex; i++) {
218	TypeBinding originalRawParam = rawOriginalGenericMethod == null ? null : rawOriginalGenericMethod.parameters[i];	230	TypeBinding originalRawParam = rawOriginalGenericMethod == null ? null : rawOriginalGenericMethod.parameters[i];
219	if (checkInvocationArgument(scope, arguments[i], params[i] , argumentTypes[i], originalRawParam)) {	231	invocationStatus \|= checkInvocationArgument(scope, arguments[i], params[i] , argumentTypes[i], originalRawParam);
220	unsafeWildcardInvocation = true;
221	}
222	}	232	}
223	int argLength = arguments.length;	233	int argLength = arguments.length;
224	if (lastIndex < argLength) { // vararg argument was provided	234	if (lastIndex < argLength) { // vararg argument was provided
Lines 233-240 Link Here
233	originalRawParam = rawOriginalGenericMethod == null ? null : ((ArrayBinding)rawOriginalGenericMethod.parameters[lastIndex]).elementsType();	243	originalRawParam = rawOriginalGenericMethod == null ? null : ((ArrayBinding)rawOriginalGenericMethod.parameters[lastIndex]).elementsType();
234	}	244	}
235	for (int i = lastIndex; i < argLength; i++) {	245	for (int i = lastIndex; i < argLength; i++) {
236	if (checkInvocationArgument(scope, arguments[i], parameterType, argumentTypes[i], originalRawParam))	246	invocationStatus \|= checkInvocationArgument(scope, arguments[i], parameterType, argumentTypes[i], originalRawParam);
237	unsafeWildcardInvocation = true;
238	}	247	}
239	}	248	}
240		249
Lines 262-276 Link Here
262	} else {	271	} else {
263	for (int i = 0; i < paramLength; i++) {	272	for (int i = 0; i < paramLength; i++) {
264	TypeBinding originalRawParam = rawOriginalGenericMethod == null ? null : rawOriginalGenericMethod.parameters[i];	273	TypeBinding originalRawParam = rawOriginalGenericMethod == null ? null : rawOriginalGenericMethod.parameters[i];
265	if (checkInvocationArgument(scope, arguments[i], params[i], argumentTypes[i], originalRawParam))	274	invocationStatus \|= checkInvocationArgument(scope, arguments[i], params[i], argumentTypes[i], originalRawParam);
266	unsafeWildcardInvocation = true;
267	}	275	}
268	}	276	}
269	if (argsContainCast) {	277	if (argsContainCast) {
270	CastExpression.checkNeedForArgumentCasts(scope, receiver, receiverType, method, arguments, argumentTypes, invocationSite);	278	CastExpression.checkNeedForArgumentCasts(scope, receiver, receiverType, method, arguments, argumentTypes, invocationSite);
271	}	279	}
272	}	280	}
273	if (unsafeWildcardInvocation) {	281	if ((invocationStatus & INVOCATION_ARGUMENT_WILDCARD) != 0) {
274	scope.problemReporter().wildcardInvocation((ASTNode)invocationSite, receiverType, method, argumentTypes);	282	scope.problemReporter().wildcardInvocation((ASTNode)invocationSite, receiverType, method, argumentTypes);
275	} else if (!method.isStatic() && !receiverType.isUnboundWildcard() && method.declaringClass.isRawType() && method.hasSubstitutedParameters()) {	283	} else if (!method.isStatic() && !receiverType.isUnboundWildcard() && method.declaringClass.isRawType() && method.hasSubstitutedParameters()) {
276	scope.problemReporter().unsafeRawInvocation((ASTNode)invocationSite, method);	284	scope.problemReporter().unsafeRawInvocation((ASTNode)invocationSite, method);

Added Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/InferenceContext.java (+142 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;
12
13	/**
14	* Context used during type inference for a generic method invocation
15	*/
16	public class InferenceContext {
17
18	private TypeBinding[][][] collectedSubstitutes;
19	MethodBinding genericMethod;
20	int depth;
21	int status;
22	TypeBinding[] substitutes;
23	final static int FAILED = 1;
24	final static int RAW_SUBSTITUTION = 2;
25
26	public InferenceContext(MethodBinding genericMethod) {
27	this.genericMethod = genericMethod;
28	TypeVariableBinding[] typeVariables = genericMethod.typeVariables;
29	int varLength = typeVariables.length;
30	this.collectedSubstitutes = new TypeBinding[varLength][3][];
31	this.substitutes = new TypeBinding[varLength];
32	}
33
34	public boolean checkRawSubstitution() {
35	// only at first level, during inference from arguments
36	if (depth > 0) return false;
37	// if (this.argumentIndex < 0 \|\| this.depth != 0) {
38	// return false;
39	// }
40	this.status = RAW_SUBSTITUTION;
41	return true;
42	}
43
44	public TypeBinding[] getSubstitutes(TypeVariableBinding typeVariable, int constraint) {
45	return this.collectedSubstitutes[typeVariable.rank][constraint];
46	}
47
48	/**
49	* Returns true if any unresolved variable is detected, i.e. any variable is substituted with itself
50	*/
51	public boolean hasUnresolvedTypeArgument() {
52	for (int i = 0, varLength = this.substitutes.length; i <varLength; i++) {
53	if (this.substitutes[i] == null) {
54	return true;
55	}
56	}
57	return false;
58	}
59
60	public void recordSubstitute(TypeVariableBinding typeVariable, TypeBinding actualType, int constraint) {
61	TypeBinding[][] variableSubstitutes = this.collectedSubstitutes[typeVariable.rank];
62	insertLoop: {
63	TypeBinding[] constraintSubstitutes = variableSubstitutes[constraint];
64	int length;
65	if (constraintSubstitutes == null) {
66	length = 0;
67	constraintSubstitutes = new TypeBinding[1];
68	} else {
69	length = constraintSubstitutes.length;
70	for (int i = 0; i < length; i++) {
71	TypeBinding substitute = constraintSubstitutes[i];
72	if (substitute == actualType) return; // already there
73	if (substitute == null) {
74	constraintSubstitutes[i] = actualType;
75	break insertLoop;
76	}
77	}
78	// no free spot found, need to grow by one
79	System.arraycopy(constraintSubstitutes, 0, constraintSubstitutes = new TypeBinding[length+1], 0, length);
80	}
81	constraintSubstitutes[length] = actualType;
82	variableSubstitutes[constraint] = constraintSubstitutes;
83	}
84	}
85	public String toString() {
86	StringBuffer buffer = new StringBuffer(20);
87	buffer.append("InferenceContex for ");//$NON-NLS-1$
88	for (int i = 0, length = this.genericMethod.typeVariables.length; i < length; i++) {
89	buffer.append(this.genericMethod.typeVariables[i]);
90	}
91	buffer.append(this.genericMethod);
92	buffer.append("\n\t[status=");//$NON-NLS-1$
93	switch(this.status) {
94	case 0 :
95	buffer.append("ok]");//$NON-NLS-1$
96	break;
97	case FAILED :
98	buffer.append("failed]");//$NON-NLS-1$
99	break;
100	case RAW_SUBSTITUTION :
101	buffer.append("raw-subst]");//$NON-NLS-1$
102	break;
103	}
104	buffer.append("[depth=").append(this.depth).append(']'); //$NON-NLS-1$
105	buffer.append("\n\t[collected={");//$NON-NLS-1$
106	for (int i = 0, length = this.collectedSubstitutes == null ? 0 : this.collectedSubstitutes.length; i < length; i++) {
107	TypeBinding[][] collected = this.collectedSubstitutes[i];
108	for (int j = TypeConstants.CONSTRAINT_EQUAL; j < TypeConstants.CONSTRAINT_SUPER; j++) {
109	TypeBinding[] constraintCollected = collected[j];
110	if (constraintCollected != null) {
111	for (int k = 0, clength = constraintCollected.length; k < clength; k++) {
112	buffer.append("\n\t\t").append(this.genericMethod.typeVariables[i].sourceName); //$NON-NLS-1$
113	switch (j) {
114	case TypeConstants.CONSTRAINT_EQUAL :
115	buffer.append("="); //$NON-NLS-1$
116	break;
117	case TypeConstants.CONSTRAINT_EXTENDS :
118	buffer.append("<:"); //$NON-NLS-1$
119	break;
120	case TypeConstants.CONSTRAINT_SUPER :
121	buffer.append(">:"); //$NON-NLS-1$
122	break;
123	}
124	buffer.append(constraintCollected[k]);
125	}
126	}
127	}
128	}
129	buffer.append("}]");//$NON-NLS-1$
130	buffer.append("\n\t[inferred=");//$NON-NLS-1$
131	int count = 0;
132	for (int i = 0, length = this.substitutes == null ? 0 : this.substitutes.length; i < length; i++) {
133	if (this.substitutes[i] == null) continue;
134	count++;
135	buffer.append('{').append(this.genericMethod.typeVariables[i].sourceName);
136	buffer.append("=").append(this.substitutes[i]).append('}'); //$NON-NLS-1$
137	}
138	if (count == 0) buffer.append("{}"); //$NON-NLS-1$
139	buffer.append(']');
140	return buffer.toString();
141	}
142	}