Attachment #122013 for bug #258798




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

	//will be a TypeReference (static message sends.....) and there is
	//no changeClass in java.
public NameReference() {
	super();
	this.bits |= Binding.TYPE | Binding.VARIABLE; // restrictiveFlag

}

public FieldBinding fieldBinding() {
	//this method should be sent ONLY after a check against isFieldReference()
	//check its use doing senders.........

	return (FieldBinding) this.binding ;
}

public boolean isSuperAccess() {
	return false;
}

public boolean isTypeAccess() {
	// null is acceptable when we are resolving the first part of a reference
	return this.binding == null || this.binding instanceof ReferenceBinding;
}

public boolean isTypeReference() {
	return this.binding instanceof ReferenceBinding;
}

public void setActualReceiverType(ReferenceBinding receiverType) {
	if (receiverType == null) return; // error scenario only
	this.actualReceiverType = receiverType;
}

public void setDepth(int depth) {
	this.bits &= ~DepthMASK; // flush previous depth if any
	if (depth > 0) {
		this.bits |= (depth & 0xFF) << DepthSHIFT; // encoded on 8 bits
	}
}

public void setFieldIndex(int index){
	// ignored
}

public void setUnchecked(boolean isUnchecked) {
	// ignored
}

public abstract String unboundReferenceErrorName();
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

			resolveReference(this.seeReferences[i], methScope);

			// see whether we can have a super reference
			if (methDecl != null && !superRef) {
				if (!methDecl.isConstructor()) {
					if (overriding && this.seeReferences[i] instanceof JavadocMessageSend) {
						JavadocMessageSend messageSend = (JavadocMessageSend) this.seeReferences[i];
						// if binding is valid then look if we have a reference to an overriden method/constructor
						if (messageSend.binding != null && messageSend.binding.isValidBinding() && messageSend.actualReceiverType instanceof ReferenceBinding) {
							ReferenceBinding methodReceiverType = (ReferenceBinding) messageSend.actualReceiverType;
							TypeBinding superType = methDecl.binding.declaringClass.findSuperTypeOriginatingFrom(methodReceiverType);
							if (superType != null && superType.original() != methDecl.binding.declaringClass && CharOperation.equals(messageSend.selector, methDecl.selector)) {
								if (methScope.environment().methodVerifier().doesMethodOverride(methDecl.binding, messageSend.binding.original())) {
									superRef = true;
								}
							else if (messageSend.arguments != null && methDecl.arguments != null) {
								superRef = methDecl.binding.areParameterErasuresEqual(messageSend.binding);
							}
						}
					}
				} else if (this.seeReferences[i] instanceof JavadocAllocationExpression) {
				else if (this.seeReferences[i] instanceof JavadocAllocationExpression) {
					JavadocAllocationExpression allocationExpr = (JavadocAllocationExpression) this.seeReferences[i];
					// if binding is valid then look if we have a reference to an overriden method/constructor
					if (allocationExpr.binding != null && allocationExpr.binding.isValidBinding()) {
						ReferenceBinding allocType = (ReferenceBinding) allocationExpr.resolvedType.original();
						ReferenceBinding superType = (ReferenceBinding) methDecl.binding.declaringClass.findSuperTypeOriginatingFrom(allocType);
						if (superType != null && superType.original() != methDecl.binding.declaringClass) {
							MethodBinding superConstructor = methScope.getConstructor(superType, methDecl.binding.parameters, allocationExpr);
							if (superConstructor.isValidBinding() && superConstructor.original() == allocationExpr.binding.original()) {
								if (superConstructor.areParametersEqual(methDecl.binding)) {
									superRef = true;
								}
							}
						}						
					}
				}
			}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AbstractVariableDeclaration.java (-1 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 128-131 Link Here
128	public void setFieldIndex(int depth) {	128	public void setFieldIndex(int depth) {
129	// do nothing by default	129	// do nothing by default
130	}	130	}
		131
		132	public void setUnchecked(boolean isUnchecked) {
		133	// ignored
		134	}
		135
131	}	136	}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-2 / +14 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 43-48 Link Here
43	// record some dependency information for exception types	43	// record some dependency information for exception types
44	ReferenceBinding[] thrownExceptions;	44	ReferenceBinding[] thrownExceptions;
45	if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {	45	if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {
		46	if ((this.bits & ASTNode.Unchecked) != 0) {
		47	thrownExceptions = currentScope.environment().convertToRawTypes(this.binding.original().thrownExceptions, true, true);
		48	}
46	// check exception handling	49	// check exception handling
47	flowContext.checkExceptionHandlers(	50	flowContext.checkExceptionHandlers(
48	thrownExceptions,	51	thrownExceptions,
Lines 353-359 Link Here
353	}	356	}
354	if (isMethodUseDeprecated(this.binding, scope, true))	357	if (isMethodUseDeprecated(this.binding, scope, true))
355	scope.problemReporter().deprecatedMethod(this.binding, this);	358	scope.problemReporter().deprecatedMethod(this.binding, this);
356	checkInvocationArguments(scope, null, allocationType, this.binding, this.arguments, argumentTypes, argsContainCast, this);	359	checkInvocationArguments(scope, null, allocationType, this.binding, this.arguments, argumentTypes, argsContainCast, this, (this.bits & ASTNode.Unchecked) != 0);
357	if (this.typeArguments != null && this.binding.original().typeVariables == Binding.NO_TYPE_VARIABLES) {	360	if (this.typeArguments != null && this.binding.original().typeVariables == Binding.NO_TYPE_VARIABLES) {
358	scope.problemReporter().unnecessaryTypeArgumentsForMethodInvocation(this.binding, this.genericTypeArguments, this.typeArguments);	361	scope.problemReporter().unnecessaryTypeArgumentsForMethodInvocation(this.binding, this.genericTypeArguments, this.typeArguments);
359	}	362	}
Lines 372-377 Link Here
372	// ignored	375	// ignored
373	}	376	}
374		377
		378	public void setUnchecked(boolean isUnchecked) {
		379	if (isUnchecked) {
		380	this.bits \|= ASTNode.Unchecked;
		381	} else {
		382	this.bits &= ~ASTNode.Unchecked;
		383	}
		384
		385	}
		386
375	public void traverse(ASTVisitor visitor, BlockScope scope) {	387	public void traverse(ASTVisitor visitor, BlockScope scope) {
376	if (visitor.visit(this, scope)) {	388	if (visitor.visit(this, scope)) {
377	if (this.typeArguments != null) {	389	if (this.typeArguments != null) {

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ExplicitConstructorCall.java (-2 / +14 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 81-86 Link Here
81		81
82	ReferenceBinding[] thrownExceptions;	82	ReferenceBinding[] thrownExceptions;
83	if ((thrownExceptions = this.binding.thrownExceptions) != Binding.NO_EXCEPTIONS) {	83	if ((thrownExceptions = this.binding.thrownExceptions) != Binding.NO_EXCEPTIONS) {
		84	if ((this.bits & ASTNode.Unchecked) != 0) {
		85	thrownExceptions = currentScope.environment().convertToRawTypes(this.binding.original().thrownExceptions, true, true);
		86	}
84	// check exceptions	87	// check exceptions
85	flowContext.checkExceptionHandlers(	88	flowContext.checkExceptionHandlers(
86	thrownExceptions,	89	thrownExceptions,
Lines 397-403 Link Here
397	if (isMethodUseDeprecated(this.binding, scope, this.accessMode != ExplicitConstructorCall.ImplicitSuper)) {	400	if (isMethodUseDeprecated(this.binding, scope, this.accessMode != ExplicitConstructorCall.ImplicitSuper)) {
398	scope.problemReporter().deprecatedMethod(this.binding, this);	401	scope.problemReporter().deprecatedMethod(this.binding, this);
399	}	402	}
400	checkInvocationArguments(scope, null, receiverType, this.binding, this.arguments, argumentTypes, argsContainCast, this);	403	checkInvocationArguments(scope, null, receiverType, this.binding, this.arguments, argumentTypes, argsContainCast, this, (this.bits & ASTNode.Unchecked) != 0);
401	if (this.binding.isPrivate() \|\| receiverType.isLocalType()) {	404	if (this.binding.isPrivate() \|\| receiverType.isLocalType()) {
402	this.binding.original().modifiers \|= ExtraCompilerModifiers.AccLocallyUsed;	405	this.binding.original().modifiers \|= ExtraCompilerModifiers.AccLocallyUsed;
403	}	406	}
Lines 430-435 Link Here
430	// ignore for here	433	// ignore for here
431	}	434	}
432		435
		436	public void setUnchecked(boolean isUnchecked) {
		437	if (isUnchecked) {
		438	this.bits \|= ASTNode.Unchecked;
		439	} else {
		440	this.bits &= ~ASTNode.Unchecked;
		441	}
		442
		443	}
		444
433	public void traverse(ASTVisitor visitor, BlockScope scope) {	445	public void traverse(ASTVisitor visitor, BlockScope scope) {
434	if (visitor.visit(this, scope)) {	446	if (visitor.visit(this, scope)) {
435	if (this.qualification != null) {	447	if (this.qualification != null) {

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FieldReference.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 609-614 Link Here
609	// ignored	609	// ignored
610	}	610	}
611		611
		612	public void setUnchecked(boolean isUnchecked) {
		613	// ignored
		614	}
		615
612	public void traverse(ASTVisitor visitor, BlockScope scope) {	616	public void traverse(ASTVisitor visitor, BlockScope scope) {
613	if (visitor.visit(this, scope)) {	617	if (visitor.visit(this, scope)) {
614	this.receiver.traverse(visitor, scope);	618	this.receiver.traverse(visitor, scope);




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

			public void setActualReceiverType(ReferenceBinding actualReceiverType) { /* ignore */}
			public void setDepth(int depth) { /* ignore */}
			public void setFieldIndex(int depth){ /* ignore */}
			public void setUnchecked(boolean isUnchecked) {/* ignore */}
			public int sourceStart() { return 0; }
			public int sourceEnd() { return 0; }
		};

				}
			}
			for (int i = 0; i < argumentLength; i++) {
				if (originalArgumentTypes[i] != alternateArgumentTypes[i]
                       /*&& !originalArgumentTypes[i].needsUncheckedConversion(alternateArgumentTypes[i])*/) {
					scope.problemReporter().unnecessaryCast((CastExpression)arguments[i]);
				}
			}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Argument.java (-2 / +1 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 93-99 Link Here
93	}	93	}
94		94
95	public TypeBinding resolveForCatch(BlockScope scope) {	95	public TypeBinding resolveForCatch(BlockScope scope) {
96
97	// resolution on an argument of a catch clause	96	// resolution on an argument of a catch clause
98	// provide the scope with a side effect : insertion of a LOCAL	97	// provide the scope with a side effect : insertion of a LOCAL
99	// that represents the argument. The type must be from JavaThrowable	98	// that represents the argument. The type must be from JavaThrowable

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/MessageSend.java (-6 / +26 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 69-74 Link Here
69	}	69	}
70	ReferenceBinding[] thrownExceptions;	70	ReferenceBinding[] thrownExceptions;
71	if ((thrownExceptions = this.binding.thrownExceptions) != Binding.NO_EXCEPTIONS) {	71	if ((thrownExceptions = this.binding.thrownExceptions) != Binding.NO_EXCEPTIONS) {
		72	if ((this.bits & ASTNode.Unchecked) != 0) {
		73	thrownExceptions = currentScope.environment().convertToRawTypes(this.binding.original().thrownExceptions, true, true);
		74	}
72	// must verify that exceptions potentially thrown by this expression are caught in the method	75	// must verify that exceptions potentially thrown by this expression are caught in the method
73	flowContext.checkExceptionHandlers(thrownExceptions, this, flowInfo.copy(), currentScope);	76	flowContext.checkExceptionHandlers(thrownExceptions, this, flowInfo.copy(), currentScope);
74	// TODO (maxime) the copy above is needed because of a side effect into	77	// TODO (maxime) the copy above is needed because of a side effect into
Lines 394-401 Link Here
394	scope.problemReporter().errorNoMethodFor(this, this.actualReceiverType, argumentTypes);	397	scope.problemReporter().errorNoMethodFor(this, this.actualReceiverType, argumentTypes);
395	return null;	398	return null;
396	}	399	}
397	this.binding =	400	this.binding = this.receiver.isImplicitThis()
398	this.receiver.isImplicitThis()
399	? scope.getImplicitMethod(this.selector, argumentTypes, this)	401	? scope.getImplicitMethod(this.selector, argumentTypes, this)
400	: scope.getMethod(this.actualReceiverType, this.selector, argumentTypes, this);	402	: scope.getMethod(this.actualReceiverType, this.selector, argumentTypes, this);
401	if (!this.binding.isValidBinding()) {	403	if (!this.binding.isValidBinding()) {
Lines 466-472 Link Here
466	scope.problemReporter().indirectAccessToStaticMethod(this, this.binding);	468	scope.problemReporter().indirectAccessToStaticMethod(this, this.binding);
467	}	469	}
468	}	470	}
469	checkInvocationArguments(scope, this.receiver, this.actualReceiverType, this.binding, this.arguments, argumentTypes, argsContainCast, this);	471	checkInvocationArguments(scope, this.receiver, this.actualReceiverType, this.binding, this.arguments, argumentTypes, argsContainCast, this, (this.bits & ASTNode.Unchecked) != 0);
470		472
471	//-------message send that are known to fail at compile time-----------	473	//-------message send that are known to fail at compile time-----------
472	if (this.binding.isAbstract()) {	474	if (this.binding.isAbstract()) {
Lines 482-489 Link Here
482	if (this.binding == scope.environment().arrayClone && compilerOptions.sourceLevel >= ClassFileConstants.JDK1_5) {	484	if (this.binding == scope.environment().arrayClone && compilerOptions.sourceLevel >= ClassFileConstants.JDK1_5) {
483	this.resolvedType = this.actualReceiverType;	485	this.resolvedType = this.actualReceiverType;
484	} else {	486	} else {
485	TypeBinding returnType = this.binding.returnType;	487	TypeBinding returnType;
486	if (returnType != null) returnType = returnType.capture(scope, this.sourceEnd);	488	if ((this.bits & ASTNode.Unchecked) != 0) {
		489	returnType = this.binding.original().returnType;
		490	if (returnType != null) {
		491	returnType = scope.environment().convertToRawType(returnType.erasure(), true);
		492	}
		493	} else {
		494	returnType = this.binding.returnType;
		495	if (returnType != null) {
		496	returnType = returnType.capture(scope, this.sourceEnd);
		497	}
		498	}
487	this.resolvedType = returnType;	499	this.resolvedType = returnType;
488	}	500	}
489	if (this.receiver.isSuper() && compilerOptions.getSeverity(CompilerOptions.OverridingMethodWithoutSuperInvocation) != ProblemSeverities.Ignore) {	501	if (this.receiver.isSuper() && compilerOptions.getSeverity(CompilerOptions.OverridingMethodWithoutSuperInvocation) != ProblemSeverities.Ignore) {
Lines 527-532 Link Here
527	// ignore for here	539	// ignore for here
528	}	540	}
529		541
		542	public void setUnchecked(boolean isUnchecked) {
		543	if (isUnchecked) {
		544	this.bits \|= ASTNode.Unchecked;
		545	} else {
		546	this.bits &= ~ASTNode.Unchecked;
		547	}
		548	}
		549
530	public void traverse(ASTVisitor visitor, BlockScope blockScope) {	550	public void traverse(ASTVisitor visitor, BlockScope blockScope) {
531	if (visitor.visit(this, blockScope)) {	551	if (visitor.visit(this, blockScope)) {
532	this.receiver.traverse(visitor, blockScope);	552	this.receiver.traverse(visitor, blockScope);




/*******************************************************************************
 * Copyright (c) 2005, 2009 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

	private ReferenceBinding enclosingType;

	public ParameterizedTypeBinding(ReferenceBinding type, TypeBinding[] arguments,  ReferenceBinding enclosingType, LookupEnvironment environment){

		this.environment = environment;
		this.enclosingType = enclosingType; // never unresolved, never lazy per construction
//		if (enclosingType != null && enclosingType.isGenericType()) {

	 *   A >> F   corresponds to:   F.collectSubstitutes(..., A, ..., CONSTRAINT_SUPER (2))
	 */
	public void collectSubstitutes(Scope scope, TypeBinding actualType, InferenceContext inferenceContext, int constraint) {
		if ((this.tagBits & TagBits.HasTypeVariable) == 0) {
			TypeBinding actualEquivalent = actualType.findSuperTypeOriginatingFrom(this.type);
			if (actualEquivalent != null && actualEquivalent.isRawType()) {
				inferenceContext.isUnchecked = true;
			}
			return;
		}
		if (actualType == TypeBinding.NULL) return;

		if (!(actualType instanceof ReferenceBinding)) return;

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

        		actualArguments = ((ParameterizedTypeBinding)actualEquivalent).arguments;
        		break;
        	case Binding.RAW_TYPE :
        		if (inferenceContext.depth > 0) {
	           		inferenceContext.status = InferenceContext.FAILED; // marker for impossible inference
        		} else {
	        		inferenceContext.isUnchecked = true;
        		}
        		return;
        	default :




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

	 * Create method of parameterized type, substituting original parameters/exception/return type with type arguments.
	 */
	public ParameterizedMethodBinding(final ParameterizedTypeBinding parameterizedDeclaringClass, MethodBinding originalMethod) {

		super(
				originalMethod.modifiers,
				originalMethod.selector,

			final TypeVariableBinding[] substitutedVariables = new TypeVariableBinding[length];
			for (int i = 0; i < length; i++) { // copy original type variable to relocate
				TypeVariableBinding originalVariable = originalVariables[i];
				substitutedVariables[i] = new TypeVariableBinding(originalVariable.sourceName, this, originalVariable.rank, parameterizedDeclaringClass.environment);
			}
			this.typeVariables = substitutedVariables;


	 * This is a CODE ASSIST method ONLY.
	 */
	public ParameterizedMethodBinding(final ReferenceBinding declaringClass, MethodBinding originalMethod, char[][] alternateParamaterNames, final LookupEnvironment environment) {

		super(
				originalMethod.modifiers,
				originalMethod.selector,

								originalVariable.sourceName :
								alternateParamaterNames[i],
							this,
							originalVariable.rank,
							environment);
			}
			this.typeVariables = substitutedVariables;





/*******************************************************************************
 * Copyright (c) 2000, 2009 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

	TypeBinding[] genericTypeArguments();
	boolean isSuperAccess();
	boolean isTypeAccess();
	void setDepth(int depth);
	void setFieldIndex(int depth);

	// in case the receiver type does not match the actual receiver type
	// e.g. pkg.Type.C (receiver type of C is type of source context,
	//		but actual receiver type is pkg.Type)
	// e.g2. in presence of implicit access to enclosing type
	void setActualReceiverType(ReferenceBinding receiverType);
	void setDepth(int depth);
	void setFieldIndex(int depth);
	/**
	 * Positioned when a method/constructor invocation is detected having required unchecked conversion
	 * for becoming applicable.
	 * @param isUnchecked
	 */
	void setUnchecked(boolean isUnchecked);
	int sourceEnd();
	int sourceStart();
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

    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
	 */
	public static MethodBinding computeCompatibleMethod(MethodBinding originalMethod, TypeBinding[] arguments, Scope scope, InvocationSite invocationSite) {

		ParameterizedGenericMethodBinding methodSubstitute;
		TypeVariableBinding[] typeVariables = originalMethod.typeVariables;
		TypeBinding[] substitutes = invocationSite.genericTypeArguments();
		TypeBinding[] uncheckedArguments = null;
		computeSubstitutes: {
			if (substitutes != null) {
				// explicit type arguments got supplied

				methodSubstitute = scope.environment().createParameterizedGenericMethod(originalMethod, substitutes);
				break computeSubstitutes;
			}

			// perform type argument inference (15.12.2.7)

			// 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);
			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()) {
				if (inferenceContext.isUnchecked) { // only remember unchecked status post 15.12.2.7
					int length = inferenceContext.substitutes.length;
					System.arraycopy(inferenceContext.substitutes, 0, uncheckedArguments = new TypeBinding[length], 0, length);
				}
				if (methodSubstitute.returnType != TypeBinding.VOID) {
					TypeBinding expectedType = null;
					// if message invocation has expected type

		}

		// bounds check
		for (int i = 0, length = typeVariables.length; i < length; i++) {
		    TypeVariableBinding typeVariable = typeVariables[i];
		    TypeBinding substitute = methodSubstitute.typeArguments[i];
		    if (uncheckedArguments != null && uncheckedArguments[i] == null) continue; // only bound check if inferred through 15.12.2.6
			switch (typeVariable.boundCheck(methodSubstitute, substitute)) {
				case TypeConstants.MISMATCH :
			        // incompatible due to bound check
					int argLength = arguments.length;
					TypeBinding[] augmentedArguments = new TypeBinding[argLength + 2]; // append offending substitute and typeVariable
					System.arraycopy(arguments, 0, augmentedArguments, 0, argLength);
					augmentedArguments[argLength] = substitute;
					augmentedArguments[argLength+1] = typeVariable;
			        return new ProblemMethodBinding(methodSubstitute, originalMethod.selector, augmentedArguments, ProblemReasons.ParameterBoundMismatch);
				case TypeConstants.UNCHECKED :
					// tolerate unchecked bounds
					invocationSite.setUnchecked(true);
					break;
				}
			}
		}
		// check presence of unchecked argument conversion a posteriori (15.12.2.6)
		return methodSubstitute;
	}


	 * 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 minArgLength = paramLength - 1;

				if (inferenceContext.status == InferenceContext.FAILED) return null; // impossible substitution
			}
		}
		if (inferenceContext.status == InferenceContext.RAW_SUBSTITUTION) {
			// 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

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

     * 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.tagBits = originalMethod.tagBits;
	    this.originalMethod = originalMethod;
	    this.parameters = Scope.substitute(this, originalMethod.parameters);
	    this.thrownExceptions = Scope.substitute(this, originalMethod.thrownExceptions);
	    // error case where exception type variable would have been substituted by a non-reference type (207573)
	    if (this.thrownExceptions == null) this.thrownExceptions = Binding.NO_EXCEPTIONS;
	    this.returnType = Scope.substitute(this, originalMethod.returnType);
	    this.thrownExceptions = Scope.substitute(this, originalMethod.thrownExceptions);
	    if (this.thrownExceptions == null) this.thrownExceptions = Binding.NO_EXCEPTIONS;
		checkMissingType: {
			if ((this.tagBits & TagBits.HasMissingType) != 0)
				break checkMissingType;

	private ParameterizedGenericMethodBinding inferFromExpectedType(Scope scope, InferenceContext inferenceContext) {
	    TypeVariableBinding[] originalVariables = this.originalMethod.typeVariables; // immediate parent (could be a parameterized method)
		int varLength = originalVariables.length;
	    // infer from expected return type
		if (inferenceContext.expectedType != null) {
		    this.returnType.collectSubstitutes(scope, inferenceContext.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++) {
			TypeVariableBinding originalVariable = originalVariables[i];
			TypeBinding argument = this.typeArguments[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
					// 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
					// 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) {
		    	// raw generic method inferred
		    	this.isRaw = true;
				this.isUnchecked = false;
		    	for (int i = 0; i < varLength; i++) {
		    		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();
		    	}
	    	}
		}
		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();
	    	}
    	}
		// may still need an extra substitution at the end (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=121369)
		// to properly substitute a remaining unresolved variable which also appear in a formal bound
    	this.typeArguments = Scope.substitute(this, this.typeArguments);

    	// adjust method types to reflect latest inference
		TypeBinding oldReturnType = this.returnType;
		this.returnType = Scope.substitute(this, this.returnType);
		this.inferredReturnType = inferenceContext.hasExplicitExpectedType && this.returnType != oldReturnType;

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/CaptureBinding.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 25-31 Link Here
25	public int position;	25	public int position;
26		26
27	public CaptureBinding(WildcardBinding wildcard, ReferenceBinding sourceType, int position, int captureID) {	27	public CaptureBinding(WildcardBinding wildcard, ReferenceBinding sourceType, int position, int captureID) {
28	super(TypeConstants.WILDCARD_CAPTURE_NAME_PREFIX, null, 0);	28	super(TypeConstants.WILDCARD_CAPTURE_NAME_PREFIX, null, 0, wildcard.environment);
29	this.wildcard = wildcard;	29	this.wildcard = wildcard;
30	this.modifiers = ClassFileConstants.AccPublic \| ExtraCompilerModifiers.AccGenericSignature; // treat capture as public	30	this.modifiers = ClassFileConstants.AccPublic \| ExtraCompilerModifiers.AccGenericSignature; // treat capture as public
31	this.fPackage = wildcard.fPackage;	31	this.fPackage = wildcard.fPackage;




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

			break;

		case Binding.TYPE_PARAMETER :
			((TypeVariableBinding) type).resolve();
			break;

		case Binding.GENERIC_TYPE :

						pendingVariable = false;
						int colon = CharOperation.indexOf(':', typeSignature, i);
						char[] variableName = CharOperation.subarray(typeSignature, i, colon);
						variables.add(new TypeVariableBinding(variableName, this, rank++, this.environment));
					}
			}
		}

// NOTE: member types of binary types are resolved when needed
public TypeVariableBinding getTypeVariable(char[] variableName) {
	TypeVariableBinding variable = super.getTypeVariable(variableName);
	variable.resolve();
	return variable;
}
private void initializeTypeVariable(TypeVariableBinding variable, TypeVariableBinding[] existingVariables, SignatureWrapper wrapper, char[][][] missingTypeNames) {

		}
	}
	for (int i = method.typeVariables.length; --i >= 0;) {
		method.typeVariables[i].resolve();
	}
	method.modifiers &= ~ExtraCompilerModifiers.AccUnresolved;
	return method;

		return this.typeVariables;

 	for (int i = this.typeVariables.length; --i >= 0;)
		this.typeVariables[i].resolve();
	this.tagBits &= ~TagBits.HasUnresolvedTypeVariables;
	return this.typeVariables;
}

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java (-21 / +149 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 45-50 Link Here
45	public int kind;	45	public int kind;
46	public Scope parent;	46	public Scope parent;
47		47
		48	protected Scope(int kind, Scope parent) {
		49	this.kind = kind;
		50	this.parent = parent;
		51	}
		52
48	/* Answer an int describing the relationship between the given types.	53	/* Answer an int describing the relationship between the given types.
49	*	54	*
50	* NOT_RELATED	55	* NOT_RELATED
Lines 59-65 Link Here
59	return Scope.NOT_RELATED;	64	return Scope.NOT_RELATED;
60	}	65	}
61		66
62	public static TypeBinding getBaseType(char[] name) {	67	/**
		68	* Returns a type where either all variables or specific ones got discarded.
		69	* e.g. List<E> (discarding <E extends Enum<E>) will return: List<? extends Enum<?>>
		70	*/
		71	public static TypeBinding convertEliminatingTypeVariables(TypeBinding originalType, ReferenceBinding genericType, int rank, Set eliminatedVariables) {
		72	if ((originalType.tagBits & TagBits.HasTypeVariable) != 0) {
		73	switch (originalType.kind()) {
		74	case Binding.ARRAY_TYPE :
		75	ArrayBinding originalArrayType = (ArrayBinding) originalType;
		76	TypeBinding originalLeafComponentType = originalArrayType.leafComponentType;
		77	TypeBinding substitute = convertEliminatingTypeVariables(originalLeafComponentType, genericType, rank, eliminatedVariables); // substitute could itself be array type
		78	if (substitute != originalLeafComponentType) {
		79	return originalArrayType.environment.createArrayType(substitute.leafComponentType(), substitute.dimensions() + originalArrayType.dimensions());
		80	}
		81	break;
		82	case Binding.PARAMETERIZED_TYPE :
		83	ParameterizedTypeBinding paramType = (ParameterizedTypeBinding) originalType;
		84	ReferenceBinding originalEnclosing = paramType.enclosingType();
		85	ReferenceBinding substitutedEnclosing = originalEnclosing;
		86	if (originalEnclosing != null) {
		87	substitutedEnclosing = (ReferenceBinding) convertEliminatingTypeVariables(originalEnclosing, genericType, rank, eliminatedVariables);
		88	}
		89	TypeBinding[] originalArguments = paramType.arguments;
		90	TypeBinding[] substitutedArguments = originalArguments;
		91	for (int i = 0, length = originalArguments == null ? 0 : originalArguments.length; i < length; i++) {
		92	TypeBinding originalArgument = originalArguments[i];
		93	TypeBinding substitutedArgument = convertEliminatingTypeVariables(originalArgument, paramType.genericType(), i, eliminatedVariables);
		94	if (substitutedArgument != originalArgument) {
		95	if (substitutedArguments == originalArguments) {
		96	System.arraycopy(originalArguments, 0, substitutedArguments = new TypeBinding[length], 0, i);
		97	}
		98	substitutedArguments[i] = substitutedArgument;
		99	} else if (substitutedArguments != originalArguments) {
		100	substitutedArguments[i] = originalArgument;
		101	}
		102	}
		103	if (originalEnclosing != substitutedEnclosing \|\| originalArguments != substitutedArguments) {
		104	return paramType.environment.createParameterizedType(paramType.genericType(), substitutedArguments, substitutedEnclosing);
		105	}
		106	break;
		107	case Binding.TYPE_PARAMETER :
		108	if (genericType == null) {
		109	break;
		110	}
		111	TypeVariableBinding originalVariable = (TypeVariableBinding) originalType;
		112	if (eliminatedVariables != null && eliminatedVariables.contains(originalType)) {
		113	return originalVariable.environment.createWildcard(genericType, rank, null, null, Wildcard.UNBOUND);
		114	}
		115	TypeBinding originalUpperBound = originalVariable.upperBound();
		116	if (eliminatedVariables == null) {
		117	eliminatedVariables = new HashSet(2);
		118	}
		119	eliminatedVariables.add(originalVariable);
		120	TypeBinding substitutedUpperBound = convertEliminatingTypeVariables(originalUpperBound, genericType, rank, eliminatedVariables);
		121	eliminatedVariables.remove(originalVariable);
		122	return originalVariable.environment.createWildcard(genericType, rank, substitutedUpperBound, null, Wildcard.EXTENDS);
		123	case Binding.RAW_TYPE :
		124	break;
		125	case Binding.GENERIC_TYPE :
		126	ReferenceBinding currentType = (ReferenceBinding) originalType;
		127	originalEnclosing = currentType.enclosingType();
		128	substitutedEnclosing = originalEnclosing;
		129	if (originalEnclosing != null) {
		130	substitutedEnclosing = (ReferenceBinding) convertEliminatingTypeVariables(originalEnclosing, genericType, rank, eliminatedVariables);
		131	}
132	originalArguments = currentType.typeVariables();
133	substitutedArguments = originalArguments;
134	for (int i = 0, length = originalArguments == null ? 0 : originalArguments.length; i < length; i++) {
135	TypeBinding originalArgument = originalArguments[i];
136	TypeBinding substitutedArgument = convertEliminatingTypeVariables(originalArgument, currentType, i, eliminatedVariables);
137	if (substitutedArgument != originalArgument) {
138	if (substitutedArguments == originalArguments) {
139	System.arraycopy(originalArguments, 0, substitutedArguments = new TypeBinding[length], 0, i);
140	}
141	substitutedArguments[i] = substitutedArgument;
142	} else if (substitutedArguments != originalArguments) {
143	substitutedArguments[i] = originalArgument;
144	}
145	}
146	if (originalEnclosing != substitutedEnclosing \|\| originalArguments != substitutedArguments) {
147	return ((TypeVariableBinding)originalArguments[0]).environment.createParameterizedType(genericType, substitutedArguments, substitutedEnclosing);
148	}
149	break;
150	case Binding.WILDCARD_TYPE :
151	WildcardBinding wildcard = (WildcardBinding) originalType;
152	TypeBinding originalBound = wildcard.bound;
153	TypeBinding substitutedBound = originalBound;
154	if (originalBound != null) {
155	substitutedBound = convertEliminatingTypeVariables(originalBound, genericType, rank, eliminatedVariables);
156	if (substitutedBound != originalBound) {
157	return wildcard.environment.createWildcard(wildcard.genericType, wildcard.rank, substitutedBound, null, wildcard.boundKind);
158	}
159	}
160	break;
161	case Binding.INTERSECTION_TYPE :
162	WildcardBinding intersection = (WildcardBinding) originalType;
163	originalBound = intersection.bound;
164	substitutedBound = originalBound;
165	if (originalBound != null) {
166	substitutedBound = convertEliminatingTypeVariables(originalBound, genericType, rank, eliminatedVariables);
167	}
168	TypeBinding[] originalOtherBounds = intersection.otherBounds;
169	TypeBinding[] substitutedOtherBounds = originalOtherBounds;
170	for (int i = 0, length = originalOtherBounds == null ? 0 : originalOtherBounds.length; i < length; i++) {
171	TypeBinding originalOtherBound = originalOtherBounds[i];
172	TypeBinding substitutedOtherBound = convertEliminatingTypeVariables(originalOtherBound, genericType, rank, eliminatedVariables);
173	if (substitutedOtherBound != originalOtherBound) {
174	if (substitutedOtherBounds == originalOtherBounds) {
175	System.arraycopy(originalOtherBounds, 0, substitutedOtherBounds = new TypeBinding[length], 0, i);
176	}
177	substitutedOtherBounds[i] = substitutedOtherBound;
178	} else if (substitutedOtherBounds != originalOtherBounds) {
179	substitutedOtherBounds[i] = originalOtherBound;
180	}
181	}
182	if (substitutedBound != originalBound \|\| substitutedOtherBounds != originalOtherBounds) {
183	return intersection.environment.createWildcard(intersection.genericType, intersection.rank, substitutedBound, substitutedOtherBounds, intersection.boundKind);
184	}
185	break;
186	}
187	}
188	return originalType;
189	}
190
191	public static TypeBinding getBaseType(char[] name) {
63	// list should be optimized (with most often used first)	192	// list should be optimized (with most often used first)
64	int length = name.length;	193	int length = name.length;
65	if (length > 2 && length < 8) {	194	if (length > 2 && length < 8) {
Lines 121-127 Link Here
121	return null;	250	return null;
122	}	251	}
123		252
124	// 5.1.10	253	// 5.1.10
125	public static ReferenceBinding[] greaterLowerBound(ReferenceBinding[] types) {	254	public static ReferenceBinding[] greaterLowerBound(ReferenceBinding[] types) {
126	if (types == null) return null;	255	if (types == null) return null;
127	int length = types.length;	256	int length = types.length;
Lines 335-345 Link Here
335	return substitutedTypes;	464	return substitutedTypes;
336	}	465	}
337		466
338	protected Scope(int kind, Scope parent) {
339	this.kind = kind;
340	this.parent = parent;
341	}
342
343	/*	467	/*
344	* Boxing primitive	468	* Boxing primitive
345	*/	469	*/
Lines 587-593 Link Here
587	int count = 0;	711	int count = 0;
588	for (int i = 0; i < length; i++) {	712	for (int i = 0; i < length; i++) {
589	TypeParameter typeParameter = typeParameters[i];	713	TypeParameter typeParameter = typeParameters[i];
590	TypeVariableBinding parameterBinding = new TypeVariableBinding(typeParameter.name, declaringElement, i);	714	TypeVariableBinding parameterBinding = new TypeVariableBinding(typeParameter.name, declaringElement, i, environment());
591	parameterBinding.fPackage = unitPackage;	715	parameterBinding.fPackage = unitPackage;
592	typeParameter.binding = parameterBinding;	716	typeParameter.binding = parameterBinding;
593		717
Lines 2665-2686 Link Here
2665	// <T extends X<Object>> void foo(T t) {}	2789	// <T extends X<Object>> void foo(T t) {}
2666	// foo(T) will show up as foo(Y#RAW) and not foo(X#RAW)	2790	// foo(T) will show up as foo(Y#RAW) and not foo(X#RAW)
2667	// Y#RAW is not more specific than a rawified X<T>	2791	// Y#RAW is not more specific than a rawified X<T>
2668	if (oneParam == one.original().parameters[i]	2792	TypeBinding originalOneParam = one.original().parameters[i].leafComponentType();
2669	&& twoParam.leafComponentType().erasure() != two.original().parameters[i].leafComponentType().erasure()) {	2793	if ((originalOneParam.isTypeVariable() ? ((TypeVariableBinding) originalOneParam).upperBound()
2670	return false;	2794	: originalOneParam).isRawType())
2671	}	2795	if (twoParam.leafComponentType().erasure() != two.original().parameters[i]
		2796	.leafComponentType().erasure())
		2797	return false;
2672	}	2798	}
2673	} else if (oneParam.isCompatibleWith(twoParam)) {	2799	} else if (oneParam.isCompatibleWith(twoParam)) {
2674	if (oneParam.leafComponentType().isRawType()) {	2800	if (oneParam.leafComponentType().isRawType()) {
2675	// A#RAW is not more specific than a rawified A<T>	2801	if (oneParam.needsUncheckedConversion(twoParam))
2676	if (oneParam.needsUncheckedConversion(two.declaringClass.isRawType() ? twoParam : two.original().parameters[i]))	2802	if (oneParam.leafComponentType().erasure() != twoParam.leafComponentType().erasure())
2677	return false;	2803	return false;
2678	}	2804	}
2679	} else {	2805	} else {
2680	if (i == oneParamsLength - 1 && one.isVarargs() && two.isVarargs()) {	2806	if (i == oneParamsLength - 1 && one.isVarargs() && two.isVarargs()) {
2681	TypeBinding eType = ((ArrayBinding) twoParam).elementsType();	2807	TypeBinding eType = ((ArrayBinding) twoParam).elementsType();
2682	if (oneParam == eType \|\| oneParam.isCompatibleWith(eType))	2808	if (oneParam == eType \|\| oneParam.isCompatibleWith(eType))
2683	return true; // special case to choose between 2 varargs methods when the last arg is Object[]	2809	return true; // special case to choose between 2 varargs methods when the last arg is
		2810	// Object[]
2684	}	2811	}
2685	return false;	2812	return false;
2686	}	2813	}
Lines 2690-2696 Link Here
2690		2817
2691	if (one.isVarargs() && two.isVarargs()) {	2818	if (one.isVarargs() && two.isVarargs()) {
2692	if (oneParamsLength > twoParamsLength) {	2819	if (oneParamsLength > twoParamsLength) {
2693	// special case when autoboxing makes (int, int...) better than (Object...) but not (int...) or (Integer, int...)	2820	// special case when autoboxing makes (int, int...) better than (Object...) but not (int...) or
		2821	// (Integer, int...)
2694	if (((ArrayBinding) twoParams[twoParamsLength - 1]).elementsType().id != TypeIds.T_JavaLangObject)	2822	if (((ArrayBinding) twoParams[twoParamsLength - 1]).elementsType().id != TypeIds.T_JavaLangObject)
2695	return false;	2823	return false;
2696	}	2824	}
Lines 2699-2710 Link Here
2699	if (oneParams[i] != twoParams[i] && !oneParams[i].isCompatibleWith(twoParams[i]))	2827	if (oneParams[i] != twoParams[i] && !oneParams[i].isCompatibleWith(twoParams[i]))
2700	return false;	2828	return false;
2701	if (parameterCompatibilityLevel(one, twoParams) == NOT_COMPATIBLE	2829	if (parameterCompatibilityLevel(one, twoParams) == NOT_COMPATIBLE
2702	&& parameterCompatibilityLevel(two, oneParams) == VARARGS_COMPATIBLE)	2830	&& parameterCompatibilityLevel(two, oneParams) == VARARGS_COMPATIBLE)
2703	return true;	2831	return true;
2704	}	2832	}
2705	return false;	2833	return false;
2706	}	2834	}
2707		2835
2708	public boolean isBoxingCompatibleWith(TypeBinding expressionType, TypeBinding targetType) {	2836	public boolean isBoxingCompatibleWith(TypeBinding expressionType, TypeBinding targetType) {
2709	LookupEnvironment environment = environment();	2837	LookupEnvironment environment = environment();
2710	if (environment.globalOptions.sourceLevel < ClassFileConstants.JDK1_5 \|\| expressionType.isBaseType() == targetType.isBaseType())	2838	if (environment.globalOptions.sourceLevel < ClassFileConstants.JDK1_5 \|\| expressionType.isBaseType() == targetType.isBaseType())




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

	public ReferenceBinding superclass;
	public ReferenceBinding[] superInterfaces;
	public char[] genericTypeSignature;
	LookupEnvironment environment;
	
	public TypeVariableBinding(char[] sourceName, Binding declaringElement, int rank, LookupEnvironment environment) {
		this.sourceName = sourceName;
		this.declaringElement = declaringElement;
		this.rank = rank;
		this.modifiers = ClassFileConstants.AccPublic | ExtraCompilerModifiers.AccGenericSignature; // treat type var as public
		this.tagBits |= TagBits.HasTypeVariable;
		this.environment = environment;
	}

	/**
	 * Returns true if the argument type satisfies all bounds of the type parameter
	 */
	public int boundCheck(Substitution substitution, TypeBinding argumentType) {
		if (argumentType == TypeBinding.NULL || argumentType == this) {
		if (argumentType == TypeBinding.NULL || argumentType == this)
			return TypeConstants.OK;
		}
		boolean hasSubstitution = substitution != null;
		if (!(argumentType instanceof ReferenceBinding || argumentType.isArrayType()))
			return TypeConstants.MISMATCH;

					TypeBinding wildcardBound = wildcard.bound;
					if (wildcardBound == this)
						return TypeConstants.OK;
					ReferenceBinding superclassBound = hasSubstitution ? (ReferenceBinding)Scope.substitute(substitution, this.superclass) : this.superclass;
					boolean isArrayBound = wildcardBound.isArrayType();
					if (!wildcardBound.isInterface()) {
						TypeBinding substitutedSuperType = hasSubstitution ? Scope.substitute(substitution, this.superclass) : this.superclass;
						if (substitutedSuperType.id != TypeIds.T_JavaLangObject) {
							if (isArrayBound) {
								if (!wildcardBound.isCompatibleWith(substitutedSuperType))
									return TypeConstants.MISMATCH;
							} else {
								TypeBinding match = wildcardBound.findSuperTypeOriginatingFrom(substitutedSuperType);
								if (match != null) {
									if (substitutedSuperType.isProvablyDistinct(match)) {
										return TypeConstants.MISMATCH;
									}
								} else {
									match =  substitutedSuperType.findSuperTypeOriginatingFrom(wildcardBound);
									if (match != null) {
										if (match.isProvablyDistinct(wildcardBound)) {
											return TypeConstants.MISMATCH;
										}
									} else {
										if (!wildcardBound.isTypeVariable() && !substitutedSuperType.isTypeVariable()) {
											return TypeConstants.MISMATCH;
										}
									}

							}
						}
					}
					ReferenceBinding[] superInterfaceBounds = hasSubstitution ? Scope.substitute(substitution, this.superInterfaces) : this.superInterfaces;
					int length = superInterfaceBounds.length;
					boolean mustImplement = isArrayBound || ((ReferenceBinding)wildcardBound).isFinal();
					for (int i = 0, length = this.superInterfaces.length; i < length; i++) {
						TypeBinding substitutedSuperType = hasSubstitution ? Scope.substitute(substitution, this.superInterfaces[i]) : this.superInterfaces[i];
						if (isArrayBound) {
							if (!wildcardBound.isCompatibleWith(substitutedSuperType))
									return TypeConstants.MISMATCH;
						} else {
							TypeBinding match = wildcardBound.findSuperTypeOriginatingFrom(substitutedSuperType);
							if (match != null) {
								if (substitutedSuperType.isProvablyDistinct(match)) {
									return TypeConstants.MISMATCH;
								}
							} else if (mustImplement) {

    public char[] readableName() {
        return this.sourceName;
    }
	ReferenceBinding resolve() {
		if ((this.modifiers & ExtraCompilerModifiers.AccUnresolved) == 0)
			return this;

		TypeBinding oldSuperclass = this.superclass, oldFirstInterface = null;
		if (this.superclass != null)
			this.superclass = (ReferenceBinding) BinaryTypeBinding.resolveType(this.superclass, this.environment, true /* raw conversion */);
		ReferenceBinding[] interfaces = this.superInterfaces;
		int length;
		if ((length = interfaces.length) != 0) {
			oldFirstInterface = interfaces[0];
			for (int i = length; --i >= 0;) {
				interfaces[i] = (ReferenceBinding) BinaryTypeBinding.resolveType(interfaces[i], this.environment, true /* raw conversion */);
			}
		}
		// refresh the firstBound in case it changed




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

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

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ClassFilePool;

	return packageBinding;
}

public TypeBinding convertEliminatingTypeVariables(TypeBinding originalType, ReferenceBinding genericType, int rank, Set eliminatedVariables) {
	if ((originalType.tagBits & TagBits.HasTypeVariable) != 0) {
		switch (originalType.kind()) {
			case Binding.ARRAY_TYPE :
				ArrayBinding originalArrayType = (ArrayBinding) originalType;
				TypeBinding originalLeafComponentType = originalArrayType.leafComponentType;
				TypeBinding substitute = convertEliminatingTypeVariables(originalLeafComponentType, genericType, rank, eliminatedVariables); // substitute could itself be array type
				if (substitute != originalLeafComponentType) {
					return createArrayType(substitute.leafComponentType(), substitute.dimensions() + originalArrayType.dimensions());
				}
				break;
			case Binding.PARAMETERIZED_TYPE :
				ParameterizedTypeBinding paramType = (ParameterizedTypeBinding) originalType;
				ReferenceBinding originalEnclosing = paramType.enclosingType();
				ReferenceBinding substitutedEnclosing = originalEnclosing;
				if (originalEnclosing != null) {
					substitutedEnclosing = (ReferenceBinding) convertEliminatingTypeVariables(originalEnclosing, genericType, rank, eliminatedVariables);
				}
				TypeBinding[] originalArguments = paramType.arguments;
				TypeBinding[] substitutedArguments = originalArguments;
				for (int i = 0, length = originalArguments == null ? 0 : originalArguments.length; i < length; i++) {
					TypeBinding originalArgument = originalArguments[i];
					TypeBinding substitutedArgument = convertEliminatingTypeVariables(originalArgument, paramType.genericType(), i, eliminatedVariables);
					if (substitutedArgument != originalArgument) {
						if (substitutedArguments == originalArguments) {
							System.arraycopy(originalArguments, 0, substitutedArguments = new TypeBinding[length], 0, i);
						}
						substitutedArguments[i] = substitutedArgument;
					} else 	if (substitutedArguments != originalArguments) {
						substitutedArguments[i] = originalArgument;
					}
				}
				if (originalEnclosing != substitutedEnclosing || originalArguments != substitutedArguments) {
					return createParameterizedType(paramType.genericType(), substitutedArguments, substitutedEnclosing);
				}
				break;
			case Binding.TYPE_PARAMETER :
				if (eliminatedVariables != null && eliminatedVariables.contains(originalType)) {
					return createWildcard(genericType, rank, null, null, Wildcard.UNBOUND);
				}
				TypeVariableBinding variable = (TypeVariableBinding) originalType;
				TypeBinding originalUpperBound = variable.upperBound();
				if (eliminatedVariables == null) {
					eliminatedVariables = new HashSet(2);
				}
				eliminatedVariables.add(variable);
				TypeBinding substitutedUpperBound = convertEliminatingTypeVariables(originalUpperBound, genericType, rank, eliminatedVariables);
				eliminatedVariables.remove(variable);
				return createWildcard(genericType, rank, substitutedUpperBound, null, Wildcard.EXTENDS);
			case Binding.RAW_TYPE :
				break;
			case Binding.GENERIC_TYPE :
				ReferenceBinding currentType = (ReferenceBinding) originalType;
				originalEnclosing = currentType.enclosingType();
				substitutedEnclosing = originalEnclosing;
				if (originalEnclosing != null) {
					substitutedEnclosing = (ReferenceBinding) convertEliminatingTypeVariables(originalEnclosing, genericType, rank, eliminatedVariables);
				}
				originalArguments = currentType.typeVariables();
				substitutedArguments = originalArguments;
				for (int i = 0, length = originalArguments == null ? 0 : originalArguments.length; i < length; i++) {
					TypeBinding originalArgument = originalArguments[i];
					TypeBinding substitutedArgument = convertEliminatingTypeVariables(originalArgument, currentType, i, eliminatedVariables);
					if (substitutedArgument != originalArgument) {
						if (substitutedArguments == originalArguments) {
							System.arraycopy(originalArguments, 0, substitutedArguments = new TypeBinding[length], 0, i);
						}
						substitutedArguments[i] = substitutedArgument;
					} else 	if (substitutedArguments != originalArguments) {
						substitutedArguments[i] = originalArgument;
					}
				}
				if (originalEnclosing != substitutedEnclosing || originalArguments != substitutedArguments) {
					return createParameterizedType(genericType, substitutedArguments, substitutedEnclosing);
				}
				break;
			case Binding.WILDCARD_TYPE :
				WildcardBinding wildcard = (WildcardBinding) originalType;
				TypeBinding originalBound = wildcard.bound;
				TypeBinding substitutedBound = originalBound;
				if (originalBound != null) {
					substitutedBound = convertEliminatingTypeVariables(originalBound, genericType, rank, eliminatedVariables);
					if (substitutedBound != originalBound) {
						return createWildcard(wildcard.genericType, wildcard.rank, substitutedBound, null, wildcard.boundKind);
					}
				}
				break;
			case Binding.INTERSECTION_TYPE :
				WildcardBinding intersection = (WildcardBinding) originalType;
				originalBound = intersection.bound;
				substitutedBound = originalBound;
				if (originalBound != null) {
					substitutedBound = convertEliminatingTypeVariables(originalBound, genericType, rank, eliminatedVariables);
				}
				TypeBinding[] originalOtherBounds = intersection.otherBounds;
				TypeBinding[] substitutedOtherBounds = originalOtherBounds;
				for (int i = 0, length = originalOtherBounds == null ? 0 : originalOtherBounds.length; i < length; i++) {
					TypeBinding originalOtherBound = originalOtherBounds[i];
					TypeBinding substitutedOtherBound = convertEliminatingTypeVariables(originalOtherBound, genericType, rank, eliminatedVariables);
					if (substitutedOtherBound != originalOtherBound) {
						if (substitutedOtherBounds == originalOtherBounds) {
							System.arraycopy(originalOtherBounds, 0, substitutedOtherBounds = new TypeBinding[length], 0, i);
						}
						substitutedOtherBounds[i] = substitutedOtherBound;
					} else 	if (substitutedOtherBounds != originalOtherBounds) {
						substitutedOtherBounds[i] = originalOtherBound;
					}
				}
				if (substitutedBound != originalBound || substitutedOtherBounds != originalOtherBounds) {
					return createWildcard(intersection.genericType, intersection.rank, substitutedBound, substitutedOtherBounds, intersection.boundKind);
				}
				break;
			}
	}
	return originalType;
}

/**
 * Convert a given source type into a parameterized form if generic.
 * generic X<E> --> param X<E>

	return type;
}

/**
 * Convert an array of types in raw forms.
 * Only allocate an array if anything is different.
 */
public ReferenceBinding[] convertToRawTypes(ReferenceBinding[] originalTypes, boolean forceErasure, boolean forceRawEnclosingType) {
	if (originalTypes == null) return null;
    ReferenceBinding[] convertedTypes = originalTypes;
    for (int i = 0, length = originalTypes.length; i < length; i++) {
        ReferenceBinding originalType = originalTypes[i];
        ReferenceBinding convertedType = (ReferenceBinding) convertToRawType(forceErasure ? originalType.erasure() : originalType, forceRawEnclosingType);
        if (convertedType != originalType) {        
            if (convertedTypes == originalTypes) {
                System.arraycopy(originalTypes, 0, convertedTypes = new ReferenceBinding[length], 0, i);
            }
            convertedTypes[i] = convertedType;
        } else if (convertedTypes != originalTypes) {
            convertedTypes[i] = originalType;
        }
    }
    return convertedTypes;
}

// variation for unresolved types in binaries (consider generic type as raw)
public TypeBinding convertUnresolvedBinaryToRawType(TypeBinding type) {

	}
	return type;
}

/*
 *  Used to guarantee annotation identity.
 */

	}
	return new AnnotationBinding(annotationType, pairs);
}

/*
 *  Used to guarantee array type identity.
 */

	this.uniqueArrayBindings[dimIndex] = arrayBindings;
	return arrayBindings[length] = new ArrayBinding(leafComponentType, dimensionCount, this);
}

public BinaryTypeBinding createBinaryTypeFrom(IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) {
	return createBinaryTypeFrom(binaryType, packageBinding, true, accessRestriction);
}

public BinaryTypeBinding createBinaryTypeFrom(IBinaryType binaryType, PackageBinding packageBinding, boolean needFieldsAndMethods, AccessRestriction accessRestriction) {
	BinaryTypeBinding binaryBinding = new BinaryTypeBinding(packageBinding, binaryType, this);


		return this.nameEnvironment.isPackage(null, name);
	return this.nameEnvironment.isPackage(compoundName, name);
}

// The method verifier is lazily initialized to guarantee the receiver, the compiler & the oracle are ready.
public MethodVerifier methodVerifier() {
	if (this.verifier == null)

			: new MethodVerifier15(this); // covariance only if sourceLevel is >= 1.5
	return this.verifier;
}

public void releaseClassFiles(org.eclipse.jdt.internal.compiler.ClassFile[] classFiles) {
	for (int i = 0, fileCount = classFiles.length; i < fileCount; i++)
		this.classFilePool.release(classFiles[i]);




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

	int status;
	TypeBinding expectedType;
	boolean hasExplicitExpectedType; // indicates whether the expectedType (if set) was explicit in code, or set by default
    public boolean isUnchecked;
	TypeBinding[] substitutes;
	final static int FAILED = 1;
	final static int RAW_SUBSTITUTION = 2;

public InferenceContext(MethodBinding genericMethod) {
	this.genericMethod = genericMethod;

	this.substitutes = new TypeBinding[varLength];
}

public boolean checkRawSubstitution() {
	// only at first level, during inference from arguments
	if (this.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];
}

		case FAILED :
			buffer.append("failed]");//$NON-NLS-1$
			break;
		case RAW_SUBSTITUTION :
			buffer.append("raw-subst]");//$NON-NLS-1$
			break;
	}
	if (this.expectedType == null) {
		buffer.append(" [expectedType=null]"); //$NON-NLS-1$

Lines 1-5 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/LocalVariableBinding.java (-2 / +1 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 53-59 Link Here
53	* Answer the receiver's binding type from Binding.BindingID.	53	* Answer the receiver's binding type from Binding.BindingID.
54	*/	54	*/
55	public final int kind() {	55	public final int kind() {
56
57	return LOCAL;	56	return LOCAL;
58	}	57	}
59		58

Lines 1-5 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetReturnStatement.java (-1 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 142-145 Link Here
142	// ignored	142	// ignored
143	}	143	}
144		144
		145	public void setUnchecked(boolean isUnchecked) {
		146	// ignored
		147	}
145	}	148	}

Lines 1-5 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetSuperReference.java (-1 / +5 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 55-59 Link Here
55	// ignored	55	// ignored
56	}	56	}
57		57
		58	public void setUnchecked(boolean isUnchecked) {
		59	// ignored
		60	}
		61
58	}	62	}
59		63




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

package org.eclipse.jdt.internal.eval;

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.CastExpression;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;

			}			
		}
	}
	checkInvocationArguments(scope, this.receiver, this.actualReceiverType, this.binding, this.arguments, argumentTypes, argsContainCast, this, (this.bits & ASTNode.Unchecked) != 0);

	//-------message send that are known to fail at compile time-----------
	if (this.binding.isAbstract()) {

		this.resolvedType = this.actualReceiverType;
	} else {
		TypeBinding returnType = this.binding.returnType;
		
		if (returnType != null) {
			if ((this.bits & ASTNode.Unchecked) != 0) {
				returnType = scope.environment().convertToRawType(returnType.erasure(), true);
			}
			returnType = returnType.capture(scope, this.sourceEnd);			
		}
		this.resolvedType = returnType;
	}
	return this.resolvedType;




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

		this.evaluationContext = evaluationContext;
		this.isImplicit = isImplicit;
	}
	
	public boolean checkAccess(MethodScope methodScope) {
		// this/super cannot be used in constructor call
		if (this.evaluationContext.isConstructorCall) {

		}
		return true;
	}
	
	public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
		int pc = codeStream.position;
		if (valueRequired) {

		}
		codeStream.recordPositionsFrom(pc, this.sourceStart);
	}
	
	/**
	 * @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#genericTypeArguments()
	 */
	public TypeBinding[] genericTypeArguments() {
		return null;
	}
	
	public boolean isSuperAccess(){
		return false;
	}
	
	public boolean isTypeAccess(){
		return false;
	}
	
	public StringBuffer printExpression(int indent, StringBuffer output){

		char[] declaringType = this.evaluationContext.declaringTypeName;

			output.append(declaringType);
		return output.append(")this"); //$NON-NLS-1$
	}
	
	public TypeBinding resolveType(BlockScope scope) {

		// implicit this
		this.constant = Constant.NotAConstant;
		TypeBinding snippetType = null;

		}
		return this.resolvedType = this.delegateThis.type;
	}
	
	public void setActualReceiverType(ReferenceBinding receiverType) {
		// ignored
	}
	
	public void setDepth(int depth){
		// ignored
	}
	
	public void setFieldIndex(int index){
		// ignored
	}
	
	public void setUnchecked(boolean isUnchecked) {
		// ignored
	}	
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
import org.eclipse.jdt.internal.compiler.IProblemFactory;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.Annotation;
import org.eclipse.jdt.internal.compiler.ast.AnnotationMethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Argument;
import org.eclipse.jdt.internal.compiler.ast.ArrayAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.ArrayQualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.ArrayReference;
import org.eclipse.jdt.internal.compiler.ast.ArrayTypeReference;
import org.eclipse.jdt.internal.compiler.ast.Assignment;
import org.eclipse.jdt.internal.compiler.ast.BinaryExpression;
import org.eclipse.jdt.internal.compiler.ast.Block;
import org.eclipse.jdt.internal.compiler.ast.BranchStatement;
import org.eclipse.jdt.internal.compiler.ast.CaseStatement;
import org.eclipse.jdt.internal.compiler.ast.CastExpression;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.CompoundAssignment;
import org.eclipse.jdt.internal.compiler.ast.ConditionalExpression;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
import org.eclipse.jdt.internal.compiler.ast.EqualExpression;
import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
import org.eclipse.jdt.internal.compiler.ast.FieldReference;
import org.eclipse.jdt.internal.compiler.ast.ImportReference;
import org.eclipse.jdt.internal.compiler.ast.Initializer;
import org.eclipse.jdt.internal.compiler.ast.InstanceOfExpression;
import org.eclipse.jdt.internal.compiler.ast.IntLiteral;
import org.eclipse.jdt.internal.compiler.ast.LabeledStatement;
import org.eclipse.jdt.internal.compiler.ast.Literal;
import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
import org.eclipse.jdt.internal.compiler.ast.LongLiteral;
import org.eclipse.jdt.internal.compiler.ast.MemberValuePair;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;
import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
import org.eclipse.jdt.internal.compiler.ast.NameReference;
import org.eclipse.jdt.internal.compiler.ast.NumberLiteral;
import org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;
import org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.Reference;
import org.eclipse.jdt.internal.compiler.ast.ReturnStatement;
import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.jdt.internal.compiler.ast.Statement;
import org.eclipse.jdt.internal.compiler.ast.SwitchStatement;
import org.eclipse.jdt.internal.compiler.ast.ThisReference;
import org.eclipse.jdt.internal.compiler.ast.TryStatement;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.ast.UnaryExpression;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.AccessRestriction;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
import org.eclipse.jdt.internal.compiler.lookup.ArrayBinding;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.InvocationSite;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedGenericMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.Scope;
import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.SyntheticArgumentBinding;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
import org.eclipse.jdt.internal.compiler.parser.JavadocTagConstants;
import org.eclipse.jdt.internal.compiler.parser.Parser;
import org.eclipse.jdt.internal.compiler.parser.RecoveryScanner;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
import org.eclipse.jdt.internal.compiler.util.Messages;

public class ProblemReporter extends ProblemHandler {

		nodeSourceStart(field,location),
		nodeSourceEnd(field, location));
}
public void unsafeRawGenericMethodInvocation(ASTNode location, MethodBinding rawMethod, TypeBinding[] argumentTypes) {
	boolean isConstructor = rawMethod.isConstructor();
	int severity = computeSeverity(isConstructor ? IProblem.UnsafeRawGenericConstructorInvocation : IProblem.UnsafeRawGenericMethodInvocation);
	if (severity == ProblemSeverities.Ignore) return;

				new String(rawMethod.declaringClass.sourceName()),
				typesAsString(rawMethod.original().isVarargs(), rawMethod.original().parameters, false),
				new String(rawMethod.declaringClass.readableName()),
				typesAsString(rawMethod.original().isVarargs(), argumentTypes, false),
			 },
			new String[] {
				new String(rawMethod.declaringClass.sourceName()),
				typesAsString(rawMethod.original().isVarargs(), rawMethod.original().parameters, true),
				new String(rawMethod.declaringClass.shortReadableName()),
				typesAsString(false, argumentTypes, true),
			 },
			severity,
			location.sourceStart,

				new String(rawMethod.selector),
				typesAsString(rawMethod.original().isVarargs(), rawMethod.original().parameters, false),
				new String(rawMethod.declaringClass.readableName()),
				typesAsString(false, argumentTypes, false),
			 },
			new String[] {
				new String(rawMethod.selector),
				typesAsString(rawMethod.original().isVarargs(), rawMethod.original().parameters, true),
				new String(rawMethod.declaringClass.shortReadableName()),
				typesAsString(false, argumentTypes, true),
			 },
			severity,
			location.sourceStart,

Lines 1-5 Link Here

(-)codeassist/org/eclipse/jdt/internal/codeassist/CompletionEngine.java (-1 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 452-457 Link Here
452	public void setActualReceiverType(ReferenceBinding receiverType) {/* empty */}	452	public void setActualReceiverType(ReferenceBinding receiverType) {/* empty */}
453	public void setDepth(int depth){/* empty */}	453	public void setDepth(int depth){/* empty */}
454	public void setFieldIndex(int depth){/* empty */}	454	public void setFieldIndex(int depth){/* empty */}
		455	public void setUnchecked(boolean isUnchecked) {/* empty */}
455	public int sourceEnd() { return 0; }	456	public int sourceEnd() { return 0; }
456	public int sourceStart() { return 0; }	457	public int sourceStart() { return 0; }
457	};	458	};




				"  }\n" +
				"}\n"
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 3)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 16)\n" + 
			"	return m_manager.getById(getClass(), new Integer(1));\n" + 
			"	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation getById(Class<capture#1-of ? extends Test>, Integer) of the generic method getById(Class<T>, Integer) of type Test.Manager<C>\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 16)\n" + 
			"	return m_manager.getById(getClass(), new Integer(1));\n" + 
			"	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type ITest needs unchecked conversion to conform to ITest<C>\n" + 
			"----------\n");
	}


				"	}\n" +
				"}\n"
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 8)\n" + 
			"	take(new A());\n" + 
			"	^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation take(Super.A) of the generic method take(Super<S>.A<S>) of type Super<Double>\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 8)\n" + 
			"	take(new A());\n" + 
			"	     ^^^^^^^\n" + 
			"Type safety: The expression of type Super.A needs unchecked conversion to conform to Super<Double>.A<Double>\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 8)\n" + 
			"	take(new A());\n" + 
			"	         ^\n" + 
			"Super.A is a raw type. References to generic type Super<S>.A<E> should be parameterized\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 14)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n");
	}


				" Zork z;\n" +
				"}\n"
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 6)\n" + 
			"	public void test(List list,final Comparator comparator, X x) {\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 6)\n" + 
			"	public void test(List list,final Comparator comparator, X x) {\n" + 
			"	                                 ^^^^^^^^^^\n" + 
			"Comparator is a raw type. References to generic type Comparator<T> should be parameterized\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 6)\n" + 
			"	public void test(List list,final Comparator comparator, X x) {\n" + 
			"	                                                        ^\n" + 
			"X is a raw type. References to generic type X<E> should be parameterized\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 7)\n" + 
			"	foo(list, comparator);\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation foo(List, Comparator) of the generic method foo(List<T>, Comparator<? super T>) of type X<E>\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 7)\n" + 
			"	foo(list, comparator);\n" + 
			"	    ^^^^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<Object>\n" + 
			"----------\n" + 
			"6. WARNING in X.java (at line 7)\n" + 
			"	foo(list, comparator);\n" + 
			"	          ^^^^^^^^^^\n" + 
			"Type safety: The expression of type Comparator needs unchecked conversion to conform to Comparator<? super Object>\n" + 
			"----------\n" + 
			"7. WARNING in X.java (at line 8)\n" + 
			"	bar(list, comparator);\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation bar(List, Comparator) of the generic method bar(List<T>, Comparator<? super T>) of type X<E>\n" + 
			"----------\n" + 
			"8. WARNING in X.java (at line 8)\n" + 
			"	bar(list, comparator);\n" + 
			"	    ^^^^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<Object>\n" + 
			"----------\n" + 
			"9. WARNING in X.java (at line 8)\n" + 
			"	bar(list, comparator);\n" + 
			"	          ^^^^^^^^^^\n" + 
			"Type safety: The expression of type Comparator needs unchecked conversion to conform to Comparator<? super Object>\n" + 
			"----------\n" + 
			"10. WARNING in X.java (at line 10)\n" + 
			"	x.foo(list, comparator);\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: The method foo(List, Comparator) belongs to the raw type X. References to generic type X<E> should be parameterized\n" + 
			"----------\n" + 
			"11. WARNING in X.java (at line 11)\n" + 
			"	x.bar(list, comparator);\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"The static method bar(List<Object>, Comparator<? super Object>) from the type X should be accessed in a static way\n" + 
			"----------\n" + 
			"12. WARNING in X.java (at line 11)\n" + 
			"	x.bar(list, comparator);\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation bar(List, Comparator) of the generic method bar(List<T>, Comparator<? super T>) of type X\n" + 
			"----------\n" + 
			"13. WARNING in X.java (at line 11)\n" + 
			"	x.bar(list, comparator);\n" + 
			"	      ^^^^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<Object>\n" + 
			"----------\n" + 
			"14. WARNING in X.java (at line 11)\n" + 
			"	x.bar(list, comparator);\n" + 
			"	            ^^^^^^^^^^\n" + 
			"Type safety: The expression of type Comparator needs unchecked conversion to conform to Comparator<? super Object>\n" + 
			"----------\n" + 
			"15. ERROR in X.java (at line 18)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n");
	}
	// array bound for wildcard

				"	}\n" +
				"}\n",
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 9)\n" + 
			"	Class c = Foo.class;\n" + 
			"	^^^^^\n" + 
			"Class is a raw type. References to generic type Class<T> should be parameterized\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<Enum> eSet = EnumSet.allOf(c);\n" + 
			"	        ^^^^\n" + 
			"Enum is a raw type. References to generic type Enum<E> should be parameterized\n" + 
			"----------\n" + 
			"3. ERROR in X.java (at line 10)\n" + 
			"	EnumSet<Enum> eSet = EnumSet.allOf(c);\n" + 
			"	        ^^^^\n" + 
			"Bound mismatch: The type Enum is not a valid substitute for the bounded parameter <E extends Enum<E>> of the type EnumSet<E>\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<Enum> eSet = EnumSet.allOf(c);\n" + 
			"	                     ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation allOf(Class) of the generic method allOf(Class<E>) of type EnumSet\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<Enum> eSet = EnumSet.allOf(c);\n" + 
			"	                     ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type EnumSet needs unchecked conversion to conform to EnumSet<Enum>\n" + 
			"----------\n" + 
			"6. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<Enum> eSet = EnumSet.allOf(c);\n" + 
			"	                                   ^\n" + 
			"Type safety: The expression of type Class needs unchecked conversion to conform to Class<Enum>\n" + 
			"----------\n");
	}
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=86838 - variation

	}
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=86838 - variation
	public void test0536() {
		this.runNegativeTest(
			new String[] {
				"X.java",
				"import java.util.EnumSet;\n" +

				"public class X {\n" +
				"	public static void main(String[] args) {\n" +
				"		Class c = Foo.class;\n" +
				"		EnumSet<?> eSet = (EnumSet<?>) EnumSet.allOf(c);\n" +
				"	}\n" +
				"  Zork z;\n" +
				"}\n",
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 9)\n" + 
			"	Class c = Foo.class;\n" + 
			"	^^^^^\n" + 
			"Class is a raw type. References to generic type Class<T> should be parameterized\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<?> eSet = (EnumSet<?>) EnumSet.allOf(c);\n" + 
			"	                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Unnecessary cast from EnumSet to EnumSet<?>\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<?> eSet = (EnumSet<?>) EnumSet.allOf(c);\n" + 
			"	                               ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation allOf(Class) of the generic method allOf(Class<E>) of type EnumSet\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<?> eSet = (EnumSet<?>) EnumSet.allOf(c);\n" + 
			"	                                             ^\n" + 
			"Type safety: The expression of type Class needs unchecked conversion to conform to Class<Enum<Enum<E>>>\n" + 
			"----------\n" + 
			"5. ERROR in X.java (at line 12)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n"
		);
	}
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=86838 - variation

				"  Zork z;\n" +
				"}\n",
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 9)\n" + 
			"	Class c = Foo.class;\n" + 
			"	^^^^^\n" + 
			"Class is a raw type. References to generic type Class<T> should be parameterized\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<?> eSet = EnumSet.allOf(c);\n" + 
			"	                  ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation allOf(Class) of the generic method allOf(Class<E>) of type EnumSet\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<?> eSet = EnumSet.allOf(c);\n" + 
			"	                                ^\n" + 
			"Type safety: The expression of type Class needs unchecked conversion to conform to Class<Enum<Enum<E>>>\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 12)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n");
	}
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=86838 - variation

				"	}\n" +
				"}\n",
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 9)\n" + 
			"	Class c = Foo.class;\n" + 
			"	^^^^^\n" + 
			"Class is a raw type. References to generic type Class<T> should be parameterized\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 10)\n" + 
			"	EnumSet<Enum<?>> eSet = EnumSet.allOf(c);\n" + 
			"	        ^^^^\n" + 
			"Bound mismatch: The type Enum<?> is not a valid substitute for the bounded parameter <E extends Enum<E>> of the type EnumSet<E>\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<Enum<?>> eSet = EnumSet.allOf(c);\n" + 
			"	                        ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation allOf(Class) of the generic method allOf(Class<E>) of type EnumSet\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<Enum<?>> eSet = EnumSet.allOf(c);\n" + 
			"	                        ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type EnumSet needs unchecked conversion to conform to EnumSet<Enum<?>>\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 10)\n" + 
			"	EnumSet<Enum<?>> eSet = EnumSet.allOf(c);\n" + 
			"	                                      ^\n" + 
			"Type safety: The expression of type Class needs unchecked conversion to conform to Class<Enum<?>>\n" + 
			"----------\n");
	}
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=86838 - variation

				"	Zork z;\n" +
				"}\n",
            },
    		"----------\n" + 
    		"1. WARNING in Ball.java (at line 2)\n" + 
    		"	class Ball implements Comparable {\n" + 
    		"	                      ^^^^^^^^^^\n" + 
    		"Comparable is a raw type. References to generic type Comparable<T> should be parameterized\n" + 
    		"----------\n" + 
    		"2. WARNING in Ball.java (at line 10)\n" + 
    		"	Collections.sort(foo);\n" + 
    		"	^^^^^^^^^^^^^^^^^^^^^\n" + 
    		"Type safety: Unchecked invocation sort(LinkedList<Ball>) of the generic method sort(List<T>) of type Collections\n" + 
    		"----------\n" + 
    		"3. ERROR in Ball.java (at line 12)\n" + 
    		"	Zork z;\n" + 
    		"	^^^^\n" + 
    		"Zork cannot be resolved to a type\n" + 
    		"----------\n");
	}
	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=81831

			"   Zork z;\n" +
			"}\n",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 13)\n" + 
		"	public class ActionImpl<T extends Base> extends Action<T> implements Comparable<ActionImpl> {\n" + 
		"	                                                                                ^^^^^^^^^^\n" + 
		"X.ActionImpl is a raw type. References to generic type X.ActionImpl<T> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 14)\n" + 
		"	public int compareTo(ActionImpl o) {\n" + 
		"	                     ^^^^^^^^^^\n" + 
		"X.ActionImpl is a raw type. References to generic type X.ActionImpl<T> should be parameterized\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 20)\n" + 
		"	Set<ActionImpl> set = new TreeSet<ActionImpl>();\n" + 
		"	    ^^^^^^^^^^\n" + 
		"X.ActionImpl is a raw type. References to generic type X.ActionImpl<T> should be parameterized\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 20)\n" + 
		"	Set<ActionImpl> set = new TreeSet<ActionImpl>();\n" + 
		"	                                  ^^^^^^^^^^\n" + 
		"X.ActionImpl is a raw type. References to generic type X.ActionImpl<T> should be parameterized\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 21)\n" + 
		"	Collections.max(set);\n" + 
		"	^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation max(Set<X.ActionImpl>) of the generic method max(Collection<? extends T>) of type Collections\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 23)\n" + 
		"	Zork z;\n" + 
		"	^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=98364

			"\n" +
			"}\n",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 20)\n" + 
		"	List<List> o = Foo.foo1();\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 20)\n" + 
		"	List<List> o = Foo.foo1();\n" + 
		"	                   ^^^^\n" + 
		"The method foo1() in the type Foo is not applicable for the arguments ()\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 21)\n" + 
		"	Foo.bar1(o);\n" + 
		"	    ^^^^\n" + 
		"The method bar1(List<List<T>>) in the type Foo is not applicable for the arguments (List<List>)\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 24)\n" + 
		"	List o = Foo.foo2();\n" + 
		"	^^^^\n" + 
		"List is a raw type. References to generic type List<E> should be parameterized\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 25)\n" + 
		"	Foo.bar2(o);\n" + 
		"	^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar2(List) of the generic method bar2(List<T>) of type Foo\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 25)\n" + 
		"	Foo.bar2(o);\n" + 
		"	         ^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<Runnable>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=114365

			"	}\n" +
			"}\n" ,
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 7)\n" + 
		"	String s = getClass();\n" + 
		"	           ^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Class<capture#1-of ? extends X> to String\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 8)\n" + 
		"	return (String) getDefault(getClass());\n" + 
		"	       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Cannot cast from X to String\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 8)\n" + 
		"	return (String) getDefault(getClass());\n" + 
		"	                ^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation getDefault(Class<capture#2-of ? extends X>) of the generic method getDefault(Class<T>) of type X<C>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=125445

		"  }\n" +
		"}\n",
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 6)\n" + 
		"	Class<? extends Enum> enumType = null;\n" + 
		"	                ^^^^\n" + 
		"Enum is a raw type. References to generic type Enum<E> should be parameterized\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 7)\n" + 
		"	final Collection<E> test = allOf(enumType);\n" + 
		"	                           ^^^^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation allOf(Class<capture#1-of ? extends Enum>) of the generic method allOf(Class<E>) of type X\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 7)\n" + 
		"	final Collection<E> test = allOf(enumType);\n" + 
		"	                           ^^^^^^^^^^^^^^^\n" + 
		"Type safety: The expression of type Collection needs unchecked conversion to conform to Collection<E>\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 9)\n" + 
		"	Collection<? extends Enum> colType = null;\n" + 
		"	                     ^^^^\n" + 
		"Enum is a raw type. References to generic type Enum<E> should be parameterized\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 10)\n" + 
		"	final Collection<E> test2 = colType;\n" + 
		"	                            ^^^^^^^\n" + 
		"Type mismatch: cannot convert from Collection<capture#2-of ? extends Enum> to Collection<E>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=119238

			"    Zork z;\n" +
			"}\n"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 7)\n" + 
		"	X x = newInstance();\n" + 
		"	^\n" + 
		"X is a raw type. References to generic type X<A> should be parameterized\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 7)\n" + 
		"	X x = newInstance();\n" + 
		"	      ^^^^^^^^^^^\n" + 
		"Bound mismatch: The generic method newInstance() of type X<A> is not applicable for the arguments (). The inferred type Comparable<Comparable<B>> is not a valid substitute for the bounded parameter <B extends Comparable<B>>\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 8)\n" + 
		"	return new X[] { x };\n" + 
		"	       ^^^^^^^^^^^^^\n" + 
		"Type safety: The expression of type X[] needs unchecked conversion to conform to X<String>[]\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 10)\n" + 
		"	Zork z;\n" + 
		"	^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=118273 - variation

		"5. WARNING in X.java (at line 7)\n" +
		"	Comparable c = newInstance2(x);\n" +
		"	                            ^\n" +
		"Type safety: The expression of type X needs unchecked conversion to conform to X<Comparable>\n" +
		"----------\n" +
		"6. ERROR in X.java (at line 9)\n" +
		"	Zork z;\n" +

			"	}\n" +
			"}", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 9)\n" + 
		"	Iterator<Number> it1 = X.chain(new Iterator[] { l1.iterator(), l2.iterator() });\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation chain(Iterator[]) of the generic method chain(Iterator<E>...) of type X\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 9)\n" + 
		"	Iterator<Number> it1 = X.chain(new Iterator[] { l1.iterator(), l2.iterator() });\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: The expression of type Iterator needs unchecked conversion to conform to Iterator<Number>\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 9)\n" + 
		"	Iterator<Number> it1 = X.chain(new Iterator[] { l1.iterator(), l2.iterator() });\n" + 
		"	                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: The expression of type Iterator[] needs unchecked conversion to conform to Iterator<Number>[]\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 14)\n" + 
		"	Iterator<Number> it2 = X.chain(l1.iterator(), l2.iterator());\n" + 
		"	                         ^^^^^\n" + 
		"The method chain(Iterator<E>...) in the type X is not applicable for the arguments (Iterator<Integer>, Iterator<Float>)\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 18)\n" + 
		"	Iterator<Number> it2 = X.chain(l1.iterator(), l1.iterator());\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety : A generic array of Iterator<Integer> is created for a varargs parameter\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=144879

			"	}\n" +
			"}", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 9)\n" + 
		"	Iterator<Number> it1 = X.chain(new Iterator[] { l1.iterator(), l2.iterator() });\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation chain(Iterator[]) of the generic method chain(Iterator<? extends T>...) of type X\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 9)\n" + 
		"	Iterator<Number> it1 = X.chain(new Iterator[] { l1.iterator(), l2.iterator() });\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: The expression of type Iterator needs unchecked conversion to conform to Iterator<Number>\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 9)\n" + 
		"	Iterator<Number> it1 = X.chain(new Iterator[] { l1.iterator(), l2.iterator() });\n" + 
		"	                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety: The expression of type Iterator[] needs unchecked conversion to conform to Iterator<? extends Number>[]\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 14)\n" + 
		"	Iterator<Number> it2 = X.chain(l1.iterator(), l2.iterator());\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety : A generic array of Iterator<? extends Number&Comparable<?>> is created for a varargs parameter\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 14)\n" + 
		"	Iterator<Number> it2 = X.chain(l1.iterator(), l2.iterator());\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Iterator<Number&Comparable<?>> to Iterator<Number>\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 18)\n" + 
		"	Iterator<Number> it2 = X.chain(l1.iterator(), l1.iterator());\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type safety : A generic array of Iterator<? extends Integer> is created for a varargs parameter\n" + 
		"----------\n" + 
		"7. ERROR in X.java (at line 18)\n" + 
		"	Iterator<Number> it2 = X.chain(l1.iterator(), l1.iterator());\n" + 
		"	                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Iterator<Integer> to Iterator<Number>\n" + 
		"----------\n");
}
public void test1001() {

			"		X x = bar(l, c);\n" +
			"	}\n" +
			"	<T> T bar(L<T> l, C<? extends T> c) { \n" +
			"		return zork;\n" +
			"	}	\n" +
			"}\n" +
			"class C<E> {}\n" +

			"\n" +
			"\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 2)\n" + 
		"	void foo(L l, C<? extends X> c) {\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)\n" + 
		"	X x = bar(l, c);\n" + 
		"	      ^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar(L, C<capture#1-of ? extends X>) of the generic method bar(L<T>, C<? extends T>) of type X\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 3)\n" + 
		"	X x = bar(l, c);\n" + 
		"	      ^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Object to X\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 3)\n" + 
		"	X x = bar(l, c);\n" + 
		"	          ^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<X>\n" + 
		"----------\n" + 
		"5. ERROR in X.java (at line 6)\n" + 
		"	return zork;\n" + 
		"	       ^^^^\n" + 
		"zork cannot be resolved\n" + 
		"----------\n",
		JavacTestOptions.EclipseJustification.EclipseBug148061);
}

			"	<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(HashMap, String, Map<String,String>) 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<String,String>\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: Unchecked invocation bar3(HashMap, String, Map<String,String>) of the generic method bar3(Map<String,String>, U, Map<U,U>) of type X\n" + 
		"----------\n" + 
		"6. 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

			"		return null;\n" +
			"	}\n" +
			"	<T> C<T> bar3(L<T> l, C<T> c) {\n" +
			"		return zork;\n" +
			"	}\n" +
			"}\n" +
			"\n" +
			"class C<E> {}\n" +
			"class L<E> {}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 2)\n" + 
		"	void foo(L l, C<X> c) {\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)\n" + 
		"	X x = bar1(l, c);\n" + 
		"	      ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar1(L, C<X>) of the generic method bar1(L<T>, C<T>) of type X\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 3)\n" + 
		"	X x = bar1(l, c);\n" + 
		"	      ^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Object to X\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 3)\n" + 
		"	X x = bar1(l, c);\n" + 
		"	           ^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<X>\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 4)\n" + 
		"	L<X> lx = bar2(l, c);\n" + 
		"	          ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar2(L, C<X>) of the generic method bar2(L<T>, C<T>) of type X\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 4)\n" + 
		"	L<X> lx = bar2(l, c);\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)\n" + 
		"	L<X> lx = bar2(l, c);\n" + 
		"	               ^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<X>\n" + 
		"----------\n" + 
		"8. WARNING in X.java (at line 5)\n" + 
		"	C<X> cx = bar3(l, c);\n" + 
		"	          ^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar3(L, C<X>) of the generic method bar3(L<T>, C<T>) of type X\n" + 
		"----------\n" + 
		"9. WARNING in X.java (at line 5)\n" + 
		"	C<X> cx = bar3(l, c);\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)\n" + 
		"	C<X> cx = bar3(l, c);\n" + 
		"	               ^\n" + 
		"Type safety: The expression of type L needs unchecked conversion to conform to L<X>\n" + 
		"----------\n" + 
		"11. ERROR in X.java (at line 14)\n" + 
		"	return zork;\n" + 
		"	       ^^^^\n" + 
		"zork cannot be resolved\n" + 
		"----------\n",
		JavacTestOptions.EclipseJustification.EclipseBug148061);
}

			"	}\n" +
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 14)\n" + 
		"	void foo(List l1, List<X> l2) {\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)\n" + 
		"	X x = bar1(l1, l2);\n" + 
		"	      ^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar1(List, List<X>) of the generic method bar1(List<T>, List<T>) of type X\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 15)\n" + 
		"	X x = bar1(l1, l2);\n" + 
		"	      ^^^^^^^^^^^^\n" + 
		"Type mismatch: cannot convert from Object to X\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 15)\n" + 
		"	X x = bar1(l1, l2);\n" + 
		"	           ^^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<X>\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 17)\n" + 
		"	List<X> lx = bar2(l1, l2);\n" + 
		"	             ^^^^^^^^^^^^\n" + 
		"Type safety: Unchecked invocation bar2(List, List<X>) of the generic method bar2(List<T>, List<T>) of type X\n" + 
		"----------\n" + 
		"6. WARNING in X.java (at line 17)\n" + 
		"	List<X> lx = bar2(l1, l2);\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)\n" + 
		"	List<X> lx = bar2(l1, l2);\n" + 
		"	                  ^^\n" + 
		"Type safety: The expression of type List needs unchecked conversion to conform to List<X>\n" + 
		"----------\n",
		JavacTestOptions.EclipseJustification.EclipseBug148061);
}

			"	<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<String>) 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<Object>\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<String>) 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<Object>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation

			"	<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<String>) 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<Object>\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<String>) 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<Object>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=148061 - variation

			"}", // =================

		},
		"----------\n" + 
		"1. WARNING in ComparableComparator.java (at line 14)\n" + 
		"	static <M extends String> Comparator<M> baz() {\n" + 
		"	                  ^^^^^^\n" + 
		"The type parameter M should not be bounded by the final type String. Final types cannot be further extended\n" + 
		"----------\n" + 
		"2. ERROR in ComparableComparator.java (at line 25)\n" + 
		"	static Comparator BAR = ComparableComparator.bar();//0\n" + 
		"	                                             ^^^\n" + 
		"Bound mismatch: The generic method bar() of type ComparableComparator<T> is not applicable for the arguments (). The inferred type Comparable<Comparable<M>> is not a valid substitute for the bounded parameter <M extends Comparable<M>>\n" + 
		"----------\n" + 
		"3. ERROR in ComparableComparator.java (at line 27)\n" + 
		"	static Object BAR2 = ComparableComparator.bar();//1a\n" + 
		"	                                          ^^^\n" + 
		"Bound mismatch: The generic method bar() of type ComparableComparator<T> is not applicable for the arguments (). The inferred type Comparable<Comparable<M>> is not a valid substitute for the bounded parameter <M extends Comparable<M>>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=158548

			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=231094
public void test1322() {
	this.runNegativeTest(
			new String[] {
					"X.java", // =================

					"class Bob2 extends Bob {}\n" +
					"class Thingy<T extends Bob> {}\n", // =================
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 6)\n" + 
			"	x.doStuff(Bob.class, new Thingy());\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation doStuff(Class<Bob>, Thingy) of the generic method doStuff(Class<T>, Thingy<T>) of type X\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 6)\n" + 
			"	x.doStuff(Bob.class, new Thingy());\n" + 
			"	                     ^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type Thingy needs unchecked conversion to conform to Thingy<Bob>\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 6)\n" + 
			"	x.doStuff(Bob.class, new Thingy());\n" + 
			"	                         ^^^^^^\n" + 
			"Thingy is a raw type. References to generic type Thingy<T> should be parameterized\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 15)\n" + 
			"	x.doStuff(Jim.class, new Thingy());\n" + 
			"	  ^^^^^^^\n" + 
			"Bound mismatch: The generic method doStuff(Class<T>, Thingy<T>) of type X is not applicable for the arguments (Class<Jim>, Thingy). The inferred type Jim is not a valid substitute for the bounded parameter <T extends Bob>\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 15)\n" + 
			"	x.doStuff(Jim.class, new Thingy());\n" + 
			"	                         ^^^^^^\n" + 
			"Thingy is a raw type. References to generic type Thingy<T> should be parameterized\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=231094 - variation
public void test1323() {
	this.runNegativeTest(
			new String[] {
					"X.java", // =================

					"class Bob2 extends Bob {}\n" +
					"class Thingy<T extends Bob> {}\n", // =================
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 4)\n" + 
			"	x.doStuff2(Jim.class, new Thingy());\n" + 
			"	  ^^^^^^^^\n" + 
			"Bound mismatch: The generic method doStuff2(Class<T>, Thingy<U>) of type X is not applicable for the arguments (Class<Jim>, Thingy). The inferred type Jim is not a valid substitute for the bounded parameter <T extends Bob>\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 4)\n" + 
			"	x.doStuff2(Jim.class, new Thingy());\n" + 
			"	                          ^^^^^^\n" + 
			"Thingy is a raw type. References to generic type Thingy<T> should be parameterized\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 5)\n" + 
			"	String s = x.doStuff2(Bob2.class, new Thingy());\n" + 
			"	           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation doStuff2(Class<Bob2>, Thingy) of the generic method doStuff2(Class<T>, Thingy<U>) of type X\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 5)\n" + 
			"	String s = x.doStuff2(Bob2.class, new Thingy());\n" + 
			"	           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type mismatch: cannot convert from Bob to String\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 5)\n" + 
			"	String s = x.doStuff2(Bob2.class, new Thingy());\n" + 
			"	                                  ^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type Thingy needs unchecked conversion to conform to Thingy<Bob>\n" + 
			"----------\n" + 
			"6. WARNING in X.java (at line 5)\n" + 
			"	String s = x.doStuff2(Bob2.class, new Thingy());\n" + 
			"	                                      ^^^^^^\n" + 
			"Thingy is a raw type. References to generic type Thingy<T> should be parameterized\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=231094 - variation
public void test1324() {
	this.runNegativeTest(
			new String[] {
					"X.java", // =================

					"class Bob {}\n" +
					"class Thingy<T extends Bob> {}\n", // =================
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 6)\n" + 
			"	x.doStuff(Bob.class, new Thingy());\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation doStuff(Class<Bob>, Thingy) of the generic method doStuff(Class<T>, Thingy<T>) of type X\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 6)\n" + 
			"	x.doStuff(Bob.class, new Thingy());\n" + 
			"	                     ^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type Thingy needs unchecked conversion to conform to Thingy<Bob>\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 6)\n" + 
			"	x.doStuff(Bob.class, new Thingy());\n" + 
			"	                         ^^^^^^\n" + 
			"Thingy is a raw type. References to generic type Thingy<T> should be parameterized\n" + 
			"----------\n" + 
			"4. ERROR in X.java (at line 8)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=231094 - variation

					"	}\n" +
					"}\n", // =================
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 5)\n" + 
			"	void bar(X x) {\n" + 
			"	         ^\n" + 
			"X is a raw type. References to generic type X<E> should be parameterized\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 6)\n" + 
			"	X<String> xs2 = foo(x);\n" + 
			"	                ^^^^^^\n" + 
			"Type safety: Unchecked invocation foo(X) of the generic method foo(X<T>) of type X<E>\n" + 
			"----------\n" + 
			"3. ERROR in X.java (at line 6)\n" + 
			"	X<String> xs2 = foo(x);\n" + 
			"	                ^^^^^^\n" + 
			"Type mismatch: cannot convert from Object to X<String>\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 6)\n" + 
			"	X<String> xs2 = foo(x);\n" + 
			"	                    ^\n" + 
			"Type safety: The expression of type X needs unchecked conversion to conform to X<Object>\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=231094 - variation
public void test1326() {
	this.runNegativeTest(
			new String[] {
					"X.java", // =================

			"2. WARNING in X.java (at line 9)\n" +
			"	X<String> xs2 = foo(x, xs).identity();\n" +
			"	                ^^^^^^^^^^\n" +
			"Type safety: Unchecked invocation foo(X, X<String>) of the generic method foo(X<T>, X<U>) of type X<E>\n" +
			"----------\n" +
			"3. WARNING in X.java (at line 9)\n" +
			"	X<String> xs2 = foo(x, xs).identity();\n" +

			"4. WARNING in X.java (at line 9)\n" +
			"	X<String> xs2 = foo(x, xs).identity();\n" +
			"	                    ^\n" +
			"Type safety: The expression of type X needs unchecked conversion to conform to X<Object>\n" +
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=231094 - variation

				"class Y<S> {}\n" +
				"class Z { Zork z; }\n", // =================
			},
			"----------\n" + 
			"1. WARNING in Scratch.java (at line 2)\n" + 
			"	private Y rawObject = new Y();\n" + 
			"	        ^\n" + 
			"Y is a raw type. References to generic type Y<S> should be parameterized\n" + 
			"----------\n" + 
			"2. WARNING in Scratch.java (at line 2)\n" + 
			"	private Y rawObject = new Y();\n" + 
			"	                          ^\n" + 
			"Y is a raw type. References to generic type Y<S> should be parameterized\n" + 
			"----------\n" + 
			"3. WARNING in Scratch.java (at line 4)\n" + 
			"	method(new X<Y<Z>>(), rawObject); // compile error in javac, unchecked conversion in Eclipse\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation method(X<Y<Z>>, Y) of the generic method method(X<T>, T) of type Scratch\n" + 
			"----------\n" + 
			"4. WARNING in Scratch.java (at line 4)\n" + 
			"	method(new X<Y<Z>>(), rawObject); // compile error in javac, unchecked conversion in Eclipse\n" + 
			"	                      ^^^^^^^^^\n" + 
			"Type safety: The expression of type Y needs unchecked conversion to conform to Y<Z>\n" + 
			"----------\n" + 
			"5. WARNING in Scratch.java (at line 5)\n" + 
			"	this.<Y<Z>>method(new X<Y<Z>>(), rawObject); // unchecked warning in both\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation method(X<Y<Z>>, Y) of the generic method method(X<T>, T) of type Scratch\n" + 
			"----------\n" + 
			"6. WARNING in Scratch.java (at line 5)\n" + 
			"	this.<Y<Z>>method(new X<Y<Z>>(), rawObject); // unchecked warning in both\n" + 
			"	                                 ^^^^^^^^^\n" + 
			"Type safety: The expression of type Y needs unchecked conversion to conform to Y<Z>\n" + 
			"----------\n" + 
			"7. ERROR in Scratch.java (at line 11)\n" + 
			"	class Z { Zork z; }\n" + 
			"	          ^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=238484

		"----------\n");
}
public void test1406() {
	this.runNegativeTest(
			new String[] {
				"GenericTest.java", //-----------------------------------------------------------------------
				"import java.util.*;\n" + 

				"    }\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in GenericTest.java (at line 5)\n" + 
			"	Set testList = GenericTest.method1(new Class[] { ArrayList.class });\n" + 
			"	^^^\n" + 
			"Set is a raw type. References to generic type Set<E> should be parameterized\n" + 
			"----------\n" + 
			"2. WARNING in GenericTest.java (at line 5)\n" + 
			"	Set testList = GenericTest.method1(new Class[] { ArrayList.class });\n" + 
			"	               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation method1(Class[]) of the generic method method1(Class<List>[]) of type GenericTest\n" + 
			"----------\n" + 
			"3. ERROR in GenericTest.java (at line 5)\n" + 
			"	Set testList = GenericTest.method1(new Class[] { ArrayList.class });\n" + 
			"	               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type mismatch: cannot convert from Object to Set\n" + 
			"----------\n" + 
			"4. WARNING in GenericTest.java (at line 5)\n" + 
			"	Set testList = GenericTest.method1(new Class[] { ArrayList.class });\n" + 
			"	                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type Class[] needs unchecked conversion to conform to Class<List>[]\n" + 
			"----------\n" + 
			"5. WARNING in GenericTest.java (at line 8)\n" + 
			"	public static <I> I method1(Class<List>[] params) {\n" + 
			"	                                  ^^^^\n" + 
			"List is a raw type. References to generic type List<E> should be parameterized\n" + 
			"----------\n");
}
public void test1407() {
	this.runNegativeTest(

				"Foo.java", //-----------------------------------------------------------------------
				"public class Foo {\n" + 
				"	public static <I> I m1(Class<Foo> c) { return null; }\n" + 
				"	public static <I> I m2(Class<I> c) { return null; }	\n" + 
				"	void bar() {\n" + 
				"		Foo l1 = m1((Class)Foo.class);\n" + 
				"		Foo l2 = m2((Class)Foo.class); //unchecked call, erased return type and error because Object != Foo		\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in Foo.java (at line 4)\n" + 
			"	Foo l1 = m1((Class)Foo.class);\n" + 
			"	            ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type Class needs unchecked conversion to conform to Class<Foo>\n" + 
			"----------\n" + 
			"2. WARNING in Foo.java (at line 5)\n" + 
			"	Foo l1 = m1((Class)Foo.class); //ok - unchecked conversion from Class to Class<Foo> - I inferred to be Foo\n" + 
			"	             ^^^^^\n" + 
			"Class is a raw type. References to generic type Class<T> should be parameterized\n" + 
			"----------\n" + 
			"3. WARNING in Foo.java (at line 6)\n" + 
			"	Foo l2 = m2((Class)Foo.class); //unchecked call, erased return type and error because Object != Foo		\n" + 
			"	         ^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation m1(Class) of the generic method m1(Class<Foo>) of type Foo\n" + 
			"----------\n" + 
			"2. ERROR in Foo.java (at line 4)\n" + 
			"	Foo l1 = m1((Class)Foo.class);\n" + 
			"	         ^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type mismatch: cannot convert from Object to Foo\n" + 
			"----------\n" + 
			"3. WARNING in Foo.java (at line 4)\n" + 
			"	Foo l1 = m1((Class)Foo.class);\n" + 
			"	            ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type Class needs unchecked conversion to conform to Class<Foo>\n" + 
			"----------\n" + 
			"4. WARNING in Foo.java (at line 4)\n" + 
			"	Foo l1 = m1((Class)Foo.class);\n" + 
			"	             ^^^^^\n" + 
			"Class is a raw type. References to generic type Class<T> should be parameterized\n" + 
			"----------\n");

			},
			"");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798
public void test1429() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"class Foo<T> {}\n" + 
				"public class X {\n" + 
				"	public void test() {\n" + 
				"		Integer i = m(new Foo<Foo<Integer>>(), new Foo());\n" + 
				"	}\n" + 
				"	public <T> T m(Foo<T> x, T t) {\n" + 
				"		return t;\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 4)\n" + 
			"	Integer i = m(new Foo<Foo<Integer>>(), new Foo());\n" + 
			"	            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation m(Foo<Foo<Integer>>, Foo) of the generic method m(Foo<T>, T) of type X\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 4)\n" + 
			"	Integer i = m(new Foo<Foo<Integer>>(), new Foo());\n" + 
			"	            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type mismatch: cannot convert from Object to Integer\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 4)\n" + 
			"	Integer i = m(new Foo<Foo<Integer>>(), new Foo());\n" + 
			"	                                       ^^^^^^^^^\n" + 
			"Type safety: The expression of type Foo needs unchecked conversion to conform to Foo<Integer>\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 4)\n" + 
			"	Integer i = m(new Foo<Foo<Integer>>(), new Foo());\n" + 
			"	                                           ^^^\n" + 
			"Foo is a raw type. References to generic type Foo<T> should be parameterized\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1430() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"class Foo<T> {}\n" + 
				"public class X {\n" + 
				"        public void test() {\n" + 
				"                m(new Foo<Foo<Integer>>(), new Foo());\n" + 
				"        }\n" + 
				"        public <T> void m(Foo<T> x, T t) {}\n" + 
				"		return t;\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 4)\n" + 
			"	m(new Foo<Foo<Integer>>(), new Foo());\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation m(Foo<Foo<Integer>>, Foo) of the generic method m(Foo<T>, T) of type X\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 4)\n" + 
			"	m(new Foo<Foo<Integer>>(), new Foo());\n" + 
			"	                           ^^^^^^^^^\n" + 
			"Type safety: The expression of type Foo needs unchecked conversion to conform to Foo<Integer>\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 4)\n" + 
			"	m(new Foo<Foo<Integer>>(), new Foo());\n" + 
			"	                               ^^^\n" + 
			"Foo is a raw type. References to generic type Foo<T> should be parameterized\n" + 
			"----------\n");
}

		"----------\n"
	);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1432() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"class Foo<T> {\n" + 
				"	T bar(Foo<T> ft, T t) {\n" + 
				"		return t;\n" + 
				"	}\n" + 
				"}\n" + 
				"public class X {\n" + 
				"	public void test() {\n" + 
				"		Foo<Foo<Integer>> ffi = new Foo<Foo<Integer>>();\n" + 
				"		Integer j = ffi.bar(ffi, new Foo());\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 9)\n" + 
			"	Integer j = ffi.bar(ffi, new Foo());\n" + 
			"	            ^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type mismatch: cannot convert from Foo<Integer> to Integer\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 9)\n" + 
			"	Integer j = ffi.bar(ffi, new Foo());\n" + 
			"	                         ^^^^^^^^^\n" + 
			"Type safety: The expression of type Foo needs unchecked conversion to conform to Foo<Integer>\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 9)\n" + 
			"	Integer j = ffi.bar(ffi, new Foo());\n" + 
			"	                             ^^^\n" + 
			"Foo is a raw type. References to generic type Foo<T> should be parameterized\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1433() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"import java.util.*;\n" + 
				"public class X<T> {\n" + 
				"	Zork z;\n" +
				"	<U> void foo(X<U> xu) {}\n" + 
				"	void bar(X x) {\n" + 
				"		foo(x);\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 3)\n" + 
			"	Zork z;\n" + 
			"	^^^^\n" + 
			"Zork cannot be resolved to a type\n" + 
			"----------\n" + 
			"2. WARNING in X.java (at line 5)\n" + 
			"	void bar(X x) {\n" + 
			"	         ^\n" + 
			"X is a raw type. References to generic type X<T> should be parameterized\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 6)\n" + 
			"	foo(x);\n" + 
			"	^^^^^^\n" + 
			"Type safety: Unchecked invocation foo(X) of the generic method foo(X<U>) of type X<T>\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 6)\n" + 
			"	foo(x);\n" + 
			"	    ^\n" + 
			"Type safety: The expression of type X needs unchecked conversion to conform to X<Object>\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1434() {
	this.runNegativeTest(
			new String[] {
				"Foo.java", //-----------------------------------------------------------------------
				"public class Foo {\n" + 
				"	public static <I> I m2(Class<I> c) { return null; }	\n" + 
				"	void bar() {\n" + 
				"		Foo l2 = m2((Class)Foo.class);\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in Foo.java (at line 4)\n" + 
			"	Foo l2 = m2((Class)Foo.class);\n" + 
			"	         ^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation m2(Class) of the generic method m2(Class<I>) of type Foo\n" + 
			"----------\n" + 
			"2. ERROR in Foo.java (at line 4)\n" + 
			"	Foo l2 = m2((Class)Foo.class);\n" + 
			"	         ^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type mismatch: cannot convert from Object to Foo\n" + 
			"----------\n" + 
			"3. WARNING in Foo.java (at line 4)\n" + 
			"	Foo l2 = m2((Class)Foo.class);\n" + 
			"	            ^^^^^^^^^^^^^^^^\n" + 
			"Type safety: The expression of type Class needs unchecked conversion to conform to Class<Foo>\n" + 
			"----------\n" + 
			"4. WARNING in Foo.java (at line 4)\n" + 
			"	Foo l2 = m2((Class)Foo.class);\n" + 
			"	            ^^^^^^^^^^^^^^^^\n" + 
			"Unnecessary cast from Class<Foo> to Class\n" + 
			"----------\n" + 
			"5. WARNING in Foo.java (at line 4)\n" + 
			"	Foo l2 = m2((Class)Foo.class);\n" + 
			"	             ^^^^^\n" + 
			"Class is a raw type. References to generic type Class<T> should be parameterized\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1435() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"public class X {\n" + 
				"	<T extends Comparable<T>>	T min(T x, T y) { return x; }\n" + 
				"	\n" + 
				"	void foo(Foo f, Bar b) {\n" + 
				"		min(f, f);\n" + 
				"		min(b, b);\n" + 
				"	}\n" + 
				"}\n" + 
				"abstract class Foo implements Comparable<Foo> {\n" + 
				"}\n" + 
				"abstract class Bar extends Foo {}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 6)\n" + 
			"	min(b, b);\n" + 
			"	^^^\n" + 
			"Bound mismatch: The generic method min(T, T) of type X is not applicable for the arguments (Bar, Bar). The inferred type Bar is not a valid substitute for the bounded parameter <T extends Comparable<T>>\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1436() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"import java.util.*;\n" + 
				"public class X {\n" + 
				"	<U extends List<?>, T extends Throwable> void foo(List<U> lu, T t) throws T {\n" + 
				"		if (lu.isEmpty()) throw t;\n" + 
				"	}\n" + 
				"	void bar(List l, IllegalArgumentException iae) {\n" + 
				"		try {\n" + 
				"			foo(l, iae);\n" + 
				"		} catch (IllegalArgumentException e) {\n" + 
				"		}\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 6)\n" + 
			"	void bar(List l, IllegalArgumentException iae) {\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 8)\n" + 
			"	foo(l, iae);\n" + 
			"	^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation foo(List, IllegalArgumentException) of the generic method foo(List<U>, T) of type X\n" + 
			"----------\n" + 
			"3. ERROR in X.java (at line 8)\n" + 
			"	foo(l, iae);\n" + 
			"	^^^^^^^^^^^\n" + 
			"Unhandled exception type Throwable\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 8)\n" + 
			"	foo(l, iae);\n" + 
			"	    ^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1437() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"import java.util.*;\n" + 
				"public class X {\n" + 
				"	<U extends List<?>, T extends Throwable> X(List<U> lu, T t) throws T {\n" + 
				"		if (lu.isEmpty()) throw t;\n" + 
				"	}\n" + 
				"	void bar(List l, IllegalArgumentException iae) {\n" + 
				"		try {\n" + 
				"			new X(l, iae);\n" + 
				"		} catch (IllegalArgumentException e) {\n" + 
				"		}\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 6)\n" + 
			"	void bar(List l, IllegalArgumentException iae) {\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 8)\n" + 
			"	new X(l, iae);\n" + 
			"	^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation X(List, IllegalArgumentException) of the generic constructor X(List<U>, T) of type X\n" + 
			"----------\n" + 
			"3. ERROR in X.java (at line 8)\n" + 
			"	new X(l, iae);\n" + 
			"	^^^^^^^^^^^^^\n" + 
			"Unhandled exception type Throwable\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 8)\n" + 
			"	new X(l, iae);\n" + 
			"	      ^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1438() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"import java.util.*;\n" + 
				"public class X {\n" + 
				"	<U extends List<?>, T extends Throwable> X(List<U> lu, T t) throws T {\n" + 
				"		if (lu.isEmpty()) throw t;\n" + 
				"	}\n" + 
				"	void bar(List l, IllegalArgumentException iae) {\n" + 
				"		try {\n" + 
				"			new X(l, iae){};\n" + 
				"		} catch (IllegalArgumentException e) {\n" + 
				"		}\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 6)\n" + 
			"	void bar(List l, IllegalArgumentException iae) {\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 8)\n" + 
			"	new X(l, iae){};\n" + 
			"	^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation X(List, IllegalArgumentException) of the generic constructor X(List<U>, T) of type X\n" + 
			"----------\n" + 
			"3. ERROR in X.java (at line 8)\n" + 
			"	new X(l, iae){};\n" + 
			"	^^^^^^^^^^^^^^^\n" + 
			"Unhandled exception type Throwable\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 8)\n" + 
			"	new X(l, iae){};\n" + 
			"	      ^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=258798 - variation
public void test1439() {
	this.runNegativeTest(
			new String[] {
				"X.java", //-----------------------------------------------------------------------
				"import java.util.*;\n" + 
				"public class X {\n" + 
				"	<U extends List<?>, T extends Throwable> X(List<U> lu, T t) throws T {\n" + 
				"		if (lu.isEmpty()) throw t;\n" + 
				"	}\n" + 
				"	X() { \n" + 
				"		this((List) null, null);\n" + 
				"	}\n" + 
				"}\n" + 
				"class Y extends X {\n" + 
				"	<U extends List<?>, T extends Throwable> Y(List<U> lu, T t) {\n" + 
				"		super((List)lu, t);\n" + 
				"	}\n" + 
				"}\n",//-----------------------------------------------------------------------
			},
			"----------\n" + 
			"1. WARNING in X.java (at line 7)\n" + 
			"	this((List) null, null);\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation X(List, null) of the generic constructor X(List<U>, T) of type X\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 7)\n" + 
			"	this((List) null, null);\n" + 
			"	^^^^^^^^^^^^^^^^^^^^^^^^\n" + 
			"Unhandled exception type Throwable\n" + 
			"----------\n" + 
			"3. WARNING in X.java (at line 7)\n" + 
			"	this((List) null, null);\n" + 
			"	     ^^^^^^^^^^^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" + 
			"----------\n" + 
			"4. WARNING in X.java (at line 7)\n" + 
			"	this((List) null, null);\n" + 
			"	      ^^^^\n" + 
			"List is a raw type. References to generic type List<E> should be parameterized\n" + 
			"----------\n" + 
			"5. WARNING in X.java (at line 12)\n" + 
			"	super((List)lu, t);\n" + 
			"	^^^^^^^^^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation X(List, T) of the generic constructor X(List<U>, T) of type X\n" + 
			"----------\n" + 
			"6. ERROR in X.java (at line 12)\n" + 
			"	super((List)lu, t);\n" + 
			"	^^^^^^^^^^^^^^^^^^^\n" + 
			"Unhandled exception type Throwable\n" + 
			"----------\n" + 
			"7. WARNING in X.java (at line 12)\n" + 
			"	super((List)lu, t);\n" + 
			"	      ^^^^^^^^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<List<?>>\n" + 
			"----------\n" + 
			"8. WARNING in X.java (at line 12)\n" + 
			"	super((List)lu, t);\n" + 
			"	       ^^^^\n" + 
			"List is a raw type. References to generic type List<E> should be parameterized\n" + 
			"----------\n");
}
}




/*******************************************************************************
 * Copyright (c) 2000, 2009 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

				"	public static <T> void foo(List<T>... e) {}\n" +
				"}\n"
			},
			"----------\n" + 
			"1. WARNING in p\\X.java (at line 6)\n" + 
			"	public X() { foo(data.l); }\n" + 
			"	             ^^^^^^^^^^^\n" + 
			"Type safety : A generic array of List<Object> is created for a varargs parameter\n" + 
			"----------\n" + 
			"2. WARNING in p\\X.java (at line 6)\n" + 
			"	public X() { foo(data.l); }\n" + 
			"	             ^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation foo(List) of the generic method foo(List<T>...) of type Z\n" + 
			"----------\n" + 
			"3. WARNING in p\\X.java (at line 6)\n" + 
			"	public X() { foo(data.l); }\n" + 
			"	                 ^^^^^^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<Object>\n" + 
			"----------\n" + 
			"----------\n" + 
			"1. WARNING in p\\Y.java (at line 4)\n" + 
			"	List l = null;\n" + 
			"	^^^^\n" + 
			"List is a raw type. References to generic type List<E> should be parameterized\n" + 
			"----------\n"
			// unchecked conversion warnings
		);

				"	public static <T> void foo(List<T>... e) {}\n" +
				"}\n"
			},
			"----------\n" + 
			"1. WARNING in p\\X.java (at line 5)\n" + 
			"	public X() { foo(data.l); }\n" + 
			"	             ^^^^^^^^^^^\n" + 
			"Type safety : A generic array of List<Object> is created for a varargs parameter\n" + 
			"----------\n" + 
			"2. WARNING in p\\X.java (at line 5)\n" + 
			"	public X() { foo(data.l); }\n" + 
			"	             ^^^^^^^^^^^\n" + 
			"Type safety: Unchecked invocation foo(List) of the generic method foo(List<T>...) of type Y\n" + 
			"----------\n" + 
			"3. WARNING in p\\X.java (at line 5)\n" + 
			"	public X() { foo(data.l); }\n" + 
			"	                 ^^^^^^\n" + 
			"Type safety: The expression of type List needs unchecked conversion to conform to List<Object>\n" + 
			"----------\n" + 
			"----------\n" + 
			"1. WARNING in p\\Y.java (at line 4)\n" + 
			"	List l = null;\n" + 
			"	^^^^\n" + 
			"List is a raw type. References to generic type List<E> should be parameterized\n" + 
			"----------\n"
			// unchecked conversion warnings
		);




/*******************************************************************************
 * Copyright (c) 2004, 2009 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

				"class W<T> extends Z<T> {\n" +
				"}",
			},
			"Lp1/X;.foo<T:Lp1/Y<-TT;>;>(Lp1/Z<TT;>;)V%<Lp1/X~Y<Lp1/X~Y;-Lp1/X~Y<Lp1/X~Y;-Lp1/X;:2TT;>;>;>"
		);
	}

	/*
	 * Ensures that a raw method binding can be created using its key in batch creation.
	 * (regression test for bug 87749 different IMethodBindings of generic method have equal getKey())
	 */
	public void test063a() throws CoreException {
		assertRequestedBindingFound(
			new String[] {
				"/P/p1/X.java",
				"package p1;\n" +
				"public class X<U extends X<T>> {\n" +
				"	public void foo(Z<U> z) {\n" +
				"    }\n" +
				"    /**\n" +
				"     * @see #foo(Z)\n" +
				"     */\n" +
				"    static void bar(X x) {\n" +
				"        /*start*/x.foo(new W())/*end*/;\n" +
				"    }\n" +
				"}\n" +
				"class Y<T> {\n" +
				"}\n" +
				"class Z<T> {\n" +
				"}\n" +
				"class W<T> extends Z<T> {\n" +
				"}",
			},
			"Lp1/X<>;.foo(Lp1/Z;)V"
		);
	}
	
	/*
	 * Ensures that a parameterized type binding with a capture binding in its arguments can be created using its key in batch creation.
	 * (regression test for bug 94092 ASTParser#createASTs(..) restores wrong bindings from capture keys)
	 */

Return to bug 258798

Lines 1-5 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java (-33 / +43 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2008 IBM Corporation and others.	2	* Copyright (c) 2000, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 2981-3002 Link Here
2981	" public static <T> void foo(List<T>... e) {}\n" +	2981	" public static <T> void foo(List<T>... e) {}\n" +
2982	"}\n"	2982	"}\n"
2983	},	2983	},
2984	"----------\n" +	2984	"----------\n" +
2985	"1. WARNING in p\\X.java (at line 6)\n" +	2985	"1. WARNING in p\\X.java (at line 6)\n" +
2986	" public X() { foo(data.l); }\n" +	2986	" public X() { foo(data.l); }\n" +
2987	" ^^^^^^^^^^^\n" +	2987	" ^^^^^^^^^^^\n" +
2988	"Type safety: Unchecked invocation foo(List...) of the generic method foo(List<T>...) of type Z\n" +	2988	"Type safety : A generic array of List<Object> is created for a varargs parameter\n" +
2989	"----------\n" +	2989	"----------\n" +
2990	"2. WARNING in p\\X.java (at line 6)\n" +	2990	"2. WARNING in p\\X.java (at line 6)\n" +
2991	" public X() { foo(data.l); }\n" +	2991	" public X() { foo(data.l); }\n" +
2992	" ^^^^^^\n" +	2992	" ^^^^^^^^^^^\n" +
2993	"Type safety: The expression of type List needs unchecked conversion to conform to List<T>\n" +	2993	"Type safety: Unchecked invocation foo(List) of the generic method foo(List<T>...) of type Z\n" +
2994	"----------\n" +	2994	"----------\n" +
2995	"----------\n" +	2995	"3. WARNING in p\\X.java (at line 6)\n" +
2996	"1. WARNING in p\\Y.java (at line 4)\n" +	2996	" public X() { foo(data.l); }\n" +
2997	" List l = null;\n" +	2997	" ^^^^^^\n" +
2998	" ^^^^\n" +	2998	"Type safety: The expression of type List needs unchecked conversion to conform to List<Object>\n" +
2999	"List is a raw type. References to generic type List<E> should be parameterized\n" +	2999	"----------\n" +
		3000	"----------\n" +
		3001	"1. WARNING in p\\Y.java (at line 4)\n" +
		3002	" List l = null;\n" +
		3003	" ^^^^\n" +
		3004	"List is a raw type. References to generic type List<E> should be parameterized\n" +
3000	"----------\n"	3005	"----------\n"
3001	// unchecked conversion warnings	3006	// unchecked conversion warnings
3002	);	3007	);
Lines 3021-3042 Link Here
3021	" public static <T> void foo(List<T>... e) {}\n" +	3026	" public static <T> void foo(List<T>... e) {}\n" +
3022	"}\n"	3027	"}\n"
3023	},	3028	},
3024	"----------\n" +	3029	"----------\n" +
3025	"1. WARNING in p\\X.java (at line 5)\n" +	3030	"1. WARNING in p\\X.java (at line 5)\n" +
3026	" public X() { foo(data.l); }\n" +	3031	" public X() { foo(data.l); }\n" +
3027	" ^^^^^^^^^^^\n" +	3032	" ^^^^^^^^^^^\n" +
3028	"Type safety: Unchecked invocation foo(List...) of the generic method foo(List<T>...) of type Y\n" +	3033	"Type safety : A generic array of List<Object> is created for a varargs parameter\n" +
3029	"----------\n" +	3034	"----------\n" +
3030	"2. WARNING in p\\X.java (at line 5)\n" +	3035	"2. WARNING in p\\X.java (at line 5)\n" +
3031	" public X() { foo(data.l); }\n" +	3036	" public X() { foo(data.l); }\n" +
3032	" ^^^^^^\n" +	3037	" ^^^^^^^^^^^\n" +
3033	"Type safety: The expression of type List needs unchecked conversion to conform to List<T>\n" +	3038	"Type safety: Unchecked invocation foo(List) of the generic method foo(List<T>...) of type Y\n" +
3034	"----------\n" +	3039	"----------\n" +
3035	"----------\n" +	3040	"3. WARNING in p\\X.java (at line 5)\n" +
3036	"1. WARNING in p\\Y.java (at line 4)\n" +	3041	" public X() { foo(data.l); }\n" +
3037	" List l = null;\n" +	3042	" ^^^^^^\n" +
3038	" ^^^^\n" +	3043	"Type safety: The expression of type List needs unchecked conversion to conform to List<Object>\n" +
3039	"List is a raw type. References to generic type List<E> should be parameterized\n" +	3044	"----------\n" +
		3045	"----------\n" +
		3046	"1. WARNING in p\\Y.java (at line 4)\n" +
		3047	" List l = null;\n" +
		3048	" ^^^^\n" +
		3049	"List is a raw type. References to generic type List<E> should be parameterized\n" +
3040	"----------\n"	3050	"----------\n"
3041	// unchecked conversion warnings	3051	// unchecked conversion warnings
3042	);	3052	);

Lines 1-5 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/BatchASTCreationTests.java (-2 / +32 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 IBM Corporation and others.	2	* Copyright (c) 2004, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 1404-1414 Link Here
1404	"class W<T> extends Z<T> {\n" +	1404	"class W<T> extends Z<T> {\n" +
1405	"}",	1405	"}",
1406	},	1406	},
1407	"Lp1/X;.foo<T:Lp1/Y<-TT;>;>(Lp1/Z<TT;>;)V%<>"	1407	"Lp1/X;.foo<T:Lp1/Y<-TT;>;>(Lp1/Z<TT;>;)V%<Lp1/X~Y<Lp1/X~Y;-Lp1/X~Y<Lp1/X~Y;-Lp1/X;:2TT;>;>;>"
1408	);	1408	);
1409	}	1409	}
1410		1410
1411	/*	1411	/*
		1412	* Ensures that a raw method binding can be created using its key in batch creation.
		1413	* (regression test for bug 87749 different IMethodBindings of generic method have equal getKey())
		1414	*/
		1415	public void test063a() throws CoreException {
		1416	assertRequestedBindingFound(
		1417	new String[] {
		1418	"/P/p1/X.java",
		1419	"package p1;\n" +
		1420	"public class X<U extends X<T>> {\n" +
		1421	" public void foo(Z<U> z) {\n" +
		1422	" }\n" +
		1423	" /**\n" +
		1424	" * @see #foo(Z)\n" +
		1425	" */\n" +
		1426	" static void bar(X x) {\n" +
		1427	" /start/x.foo(new W())/end/;\n" +
		1428	" }\n" +
		1429	"}\n" +
		1430	"class Y<T> {\n" +
		1431	"}\n" +
		1432	"class Z<T> {\n" +
		1433	"}\n" +
		1434	"class W<T> extends Z<T> {\n" +
		1435	"}",
		1436	},
		1437	"Lp1/X<>;.foo(Lp1/Z;)V"
		1438	);
		1439	}
		1440
		1441	/*
1412	* Ensures that a parameterized type binding with a capture binding in its arguments can be created using its key in batch creation.	1442	* Ensures that a parameterized type binding with a capture binding in its arguments can be created using its key in batch creation.
1413	* (regression test for bug 94092 ASTParser#createASTs(..) restores wrong bindings from capture keys)	1443	* (regression test for bug 94092 ASTParser#createASTs(..) restores wrong bindings from capture keys)
1414	*/	1444	*/