Attachment #64742 for bug #183216





import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
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.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;

/**
 * Variation on allocation, where can optionally be specified any of:

		FlowInfo flowInfo) {

		// analyse the enclosing instance
		if (this.enclosingInstance != null) {
			flowInfo = this.enclosingInstance.analyseCode(currentScope, flowContext, flowInfo);
		}
		
		// check captured variables are initialized in current context (26134)

			flowInfo);
		
		// process arguments
		if (this.arguments != null) {
			for (int i = 0, count = this.arguments.length; i < count; i++) {
				flowInfo = this.arguments[i].analyseCode(currentScope, flowContext, flowInfo);
			}
		}

		// analyse the anonymous nested type
		if (this.anonymousType != null) {
			flowInfo = this.anonymousType.analyseCode(currentScope, flowContext, flowInfo);
		}

		// record some dependency information for exception types
		ReferenceBinding[] thrownExceptions;
		if (((thrownExceptions = this.binding.thrownExceptions).length) != 0) {
			// check exception handling
			flowContext.checkExceptionHandlers(
				thrownExceptions,


	public Expression enclosingInstance() {

		return this.enclosingInstance;
	}

	public void generateCode(

			codeStream.recordPositionsFrom(pc, this.type.sourceStart);
		} else {
			// push enum constant name and ordinal
			codeStream.ldc(String.valueOf(this.enumConstant.name));
			codeStream.generateInlinedValue(this.enumConstant.binding.id);
		}
		// handling innerclass instance allocation - enclosing instance arguments
		if (allocatedType.isNestedType()) {

				this);
		}
		// generate the arguments for constructor
		generateArguments(this.binding, this.arguments, currentScope, codeStream);
		// handling innerclass instance allocation - outer local arguments
		if (allocatedType.isNestedType()) {
			codeStream.generateSyntheticOuterArgumentValues(

		}
		
		// invoke constructor
		if (this.syntheticAccessor == null) {
			codeStream.invokespecial(this.codegenBinding);
		} else {
			// synthetic accessor got some extra arguments appended to its signature, which need values
			for (int i = 0,
				max = this.syntheticAccessor.parameters.length - this.codegenBinding.parameters.length;
				i < max;
				i++) {
				codeStream.aconst_null();
			}
			codeStream.invokespecial(this.syntheticAccessor);
		}
		codeStream.generateImplicitConversion(this.implicitConversion);
		codeStream.recordPositionsFrom(pc, this.sourceStart);

		if (this.anonymousType != null) {
			this.anonymousType.generateCode(currentScope, codeStream);
		}
	}
	
	public boolean isSuperAccess() {

		// necessary to lookup super constructor of anonymous type
		return this.anonymousType != null;
	}
	
	/* Inner emulation consists in either recording a dependency 

	public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {

		if ((flowInfo.tagBits & FlowInfo.UNREACHABLE) == 0)	{
		ReferenceBinding allocatedTypeErasure = (ReferenceBinding) this.binding.declaringClass.erasure();

		// perform some extra emulation work in case there is some and we are inside a local type only
		if (allocatedTypeErasure.isNestedType()
			&& currentScope.enclosingSourceType().isLocalType()) {

			if (allocatedTypeErasure.isLocalType()) {
				((LocalTypeBinding) allocatedTypeErasure).addInnerEmulationDependent(currentScope, this.enclosingInstance != null);
			} else {
				// locally propagate, since we already now the desired shape for sure
				currentScope.propagateInnerEmulation(allocatedTypeErasure, this.enclosingInstance != null);
			}
		}
		}


	public StringBuffer printExpression(int indent, StringBuffer output) {

		if (this.enclosingInstance != null)
			this.enclosingInstance.printExpression(0, output).append('.'); 
		super.printExpression(0, output);
		if (this.anonymousType != null) {
			this.anonymousType.print(indent, output);
		}
		return output;
	}

		// ClassInstanceCreationExpression ::= Primary '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
		// ClassInstanceCreationExpression ::= Name '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
		
		this.constant = Constant.NotAConstant;
		TypeBinding enclosingInstanceType = null;
		TypeBinding receiverType = null;
		boolean hasError = false;
		boolean enclosingInstanceContainsCast = false;
		boolean argsContainCast = false;
		
		if (this.enclosingInstance != null) {
			if (this.enclosingInstance instanceof CastExpression) {
				this.enclosingInstance.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on
				enclosingInstanceContainsCast = true;
			}
			if ((enclosingInstanceType = this.enclosingInstance.resolveType(scope)) == null){
				hasError = true;
			} else if (enclosingInstanceType.isBaseType() || enclosingInstanceType.isArrayType()) {
				scope.problemReporter().illegalPrimitiveOrArrayTypeForEnclosingInstance(
					enclosingInstanceType,
					this.enclosingInstance);
				hasError = true;
			} else if (this.type instanceof QualifiedTypeReference) {
				scope.problemReporter().illegalUsageOfQualifiedTypeReference((QualifiedTypeReference)this.type);
				hasError = true;
			} else {
				receiverType = ((SingleTypeReference) this.type).resolveTypeEnclosing(scope, (ReferenceBinding) enclosingInstanceType);
				if (receiverType != null && enclosingInstanceContainsCast) {
					CastExpression.checkNeedForEnclosingInstanceCast(scope, this.enclosingInstance, enclosingInstanceType, receiverType);
				}
			}
		} else {

		} else if (((ReferenceBinding) receiverType).isFinal()) {
			if (this.anonymousType != null) {
				if (!receiverType.isEnum()) {
					scope.problemReporter().anonymousClassCannotExtendFinalClass(this.type, receiverType);
					hasError = true;
				}
			} else if (!receiverType.canBeInstantiated()) {
				scope.problemReporter().cannotInstantiate(this.type, receiverType);
				return this.resolvedType = receiverType;
			}
		}

		
		// will check for null after args are resolved
		TypeBinding[] argumentTypes = Binding.NO_PARAMETERS;
		if (this.arguments != null) {
			int length = this.arguments.length;
			argumentTypes = new TypeBinding[length];
			for (int i = 0; i < length; i++) {
				Expression argument = this.arguments[i];
				if (argument instanceof CastExpression) {
					argument.bits |= ASTNode.DisableUnnecessaryCastCheck; // will check later on
					argsContainCast = true;
				}
				if ((argumentTypes[i] = argument.resolveType(scope)) == null){

		if (this.anonymousType == null) {
			// qualified allocation with no anonymous type
			if (!receiverType.canBeInstantiated()) {
				scope.problemReporter().cannotInstantiate(this.type, receiverType);
				return this.resolvedType = receiverType;
			}
			ReferenceBinding allocationType = (ReferenceBinding) receiverType;
			if ((this.binding = scope.getConstructor(allocationType, argumentTypes, this)).isValidBinding()) {
				if (isMethodUseDeprecated(this.binding, scope, true)) {
					scope.problemReporter().deprecatedMethod(this.binding, this);
				}
				checkInvocationArguments(scope, null, allocationType, this.binding, this.arguments, argumentTypes, argsContainCast, this);
			} else {
				if (this.binding.declaringClass == null) {
					this.binding.declaringClass = allocationType;

			if (expectedType != enclosingInstanceType) // must call before computeConversion() and typeMismatchError()
				scope.compilationUnitScope().recordTypeConversion(expectedType, enclosingInstanceType);
			if (enclosingInstanceType.isCompatibleWith(expectedType) || scope.isBoxingCompatibleWith(enclosingInstanceType, expectedType)) {
				this.enclosingInstance.computeConversion(scope, expectedType, enclosingInstanceType);
				return this.resolvedType = receiverType;
			}
			scope.problemReporter().typeMismatchError(enclosingInstanceType, expectedType, this.enclosingInstance);

			receiverType = new ProblemReferenceBinding(receiverType.sourceName(), (ReferenceBinding)receiverType, ProblemReasons.IllegalSuperTypeVariable);
			scope.problemReporter().invalidType(this, receiverType);
			return null;
		} else if (this.type != null && receiverType.isEnum()) { // tolerate enum constant body
			scope.problemReporter().cannotInstantiate(this.type, receiverType);
			return this.resolvedType = receiverType;
		}
		// anonymous type scenario

		// insert anonymous type in scope
		scope.addAnonymousType(this.anonymousType, (ReferenceBinding) receiverType);
		this.anonymousType.resolve(scope);		
		if (this.superTypeBinding.erasure().id == TypeIds.T_JavaLangEnum) {
			scope.problemReporter().cannotExtendEnum(this.anonymousType.binding, this.type, this.superTypeBinding);
		}
		
		if ((receiverType.tagBits & TagBits.HasDirectWildcard) != 0) {
			scope.problemReporter().superTypeCannotUseWildcard(this.anonymousType.binding, this.type, receiverType);
		}		
		// find anonymous super constructor
		MethodBinding inheritedBinding = scope.getConstructor(this.superTypeBinding, argumentTypes, this);

				inheritedBinding.declaringClass = this.superTypeBinding;
			}
			scope.problemReporter().invalidConstructor(this, inheritedBinding);
			return this.resolvedType = this.anonymousType.binding;
		}
		if (this.enclosingInstance != null) {
			ReferenceBinding targetEnclosing = inheritedBinding.declaringClass.enclosingType();
			if (targetEnclosing == null) {
				scope.problemReporter().unnecessaryEnclosingInstanceSpecification(this.enclosingInstance, (ReferenceBinding)receiverType);
				return this.resolvedType = this.anonymousType.binding;
			} else if (!enclosingInstanceType.isCompatibleWith(targetEnclosing) && !scope.isBoxingCompatibleWith(enclosingInstanceType, targetEnclosing)) {
				scope.problemReporter().typeMismatchError(enclosingInstanceType, targetEnclosing, this.enclosingInstance);
				return this.resolvedType = this.anonymousType.binding;
			}
			this.enclosingInstance.computeConversion(scope, targetEnclosing, enclosingInstanceType);
		}
		if (this.arguments != null)
			checkInvocationArguments(scope, null, this.superTypeBinding, inheritedBinding, this.arguments, argumentTypes, argsContainCast, this);

		// Update the anonymous inner class : superclass, interface  
		this.binding = this.anonymousType.createDefaultConstructorWithBinding(inheritedBinding);
		return this.resolvedType = this.anonymousType.binding; // 1.2 change
	}
	
	public void traverse(ASTVisitor visitor, BlockScope scope) {

		if (visitor.visit(this, scope)) {
			if (this.enclosingInstance != null)
				this.enclosingInstance.traverse(visitor, scope);
			if (this.typeArguments != null) {
				for (int i = 0, typeArgumentsLength = this.typeArguments.length; i < typeArgumentsLength; i++) {
					this.typeArguments[i].traverse(visitor, scope);

			}
			if (this.type != null) // case of enum constant
				this.type.traverse(visitor, scope);
			if (this.arguments != null) {
				int argumentsLength = this.arguments.length;
				for (int i = 0; i < argumentsLength; i++)
					this.arguments[i].traverse(visitor, scope);
			}
			if (this.anonymousType != null)
				this.anonymousType.traverse(visitor, scope);
		}
		visitor.endVisit(this, scope);
	}

Lines 120-126 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedSingleTypeReference.java (-5 / +8 lines)
120	: scope.environment().convertToParameterizedType(enclosingType);	120	: scope.environment().convertToParameterizedType(enclosingType);
121	}	121	}
122	} else { // resolving member type (relatively to enclosingType)	122	} else { // resolving member type (relatively to enclosingType)
123	this.resolvedType = scope.getMemberType(token, (ReferenceBinding)enclosingType.erasure());	123	this.resolvedType = scope.getMemberType(token, enclosingType);
124	if (!this.resolvedType.isValidBinding()) {	124	if (!this.resolvedType.isValidBinding()) {
125	scope.problemReporter().invalidEnclosingType(this, this.resolvedType, enclosingType);	125	scope.problemReporter().invalidEnclosingType(this, this.resolvedType, enclosingType);
126	return null;	126	return null;
Lines 165-174 Link Here
165	} else if (argLength != typeVariables.length) { // check arity	165	} else if (argLength != typeVariables.length) { // check arity
166	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);	166	scope.problemReporter().incorrectArityForParameterizedType(this, currentType, argTypes);
167	return null;	167	return null;
168	} else if (!currentType.isStatic() && enclosingType != null && enclosingType.isRawType()){	168	} else if (!currentType.isStatic()) {
169	scope.problemReporter().rawMemberTypeCannotBeParameterized(	169	ReferenceBinding actualEnclosing = currentType.enclosingType();
170	this, scope.environment().createRawType((ReferenceBinding)currentType.erasure(), enclosingType), argTypes);	170	if (actualEnclosing != null && actualEnclosing.isRawType()){
171	return null;	171	scope.problemReporter().rawMemberTypeCannotBeParameterized(
		172	this, scope.environment().createRawType((ReferenceBinding)currentType.erasure(), actualEnclosing), argTypes);
		173	return null;
		174	}
172	}	175	}
173		176
174	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType((ReferenceBinding)currentType.erasure(), argTypes, enclosingType);	177	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType((ReferenceBinding)currentType.erasure(), argTypes, enclosingType);




					return null;
				}
				// check parameterizing non-static member type of raw type
				if (typeIsConsistent && !currentType.isStatic()) {
					ReferenceBinding actualEnclosing = currentType.enclosingType();
					if (actualEnclosing != null && actualEnclosing.isRawType()) {
						scope.problemReporter().rawMemberTypeCannotBeParameterized(
								this, scope.environment().createRawType((ReferenceBinding)currentType.erasure(), actualEnclosing), argTypes);
						typeIsConsistent = false;				
					}
				}				
				ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType((ReferenceBinding)currentType.erasure(), argTypes, qualifiedType);
				// check argument type compatibility
				if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution

			}
			if (isTypeUseDeprecated(qualifiedType, scope))
				reportDeprecatedType(qualifiedType, scope);		    
			this.resolvedType = qualifiedType;
		}
//		this.resolvedType = qualifiedType;
		// array type ?
		if (this.dimensions > 0) {
			if (dimensions > 255)




		"Type mismatch: cannot convert from element type Object to Map.Entry<String,String>\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=183216
public void test1125() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"class A {\n" + 
			"    class B<T> {\n" + 
			"        T t;\n" + 
			"        T getValue() {\n" + 
			"            return t;\n" + 
			"        }\n" + 
			"    }\n" + 
			"}\n" + 
			"\n" + 
			"class C<T> extends A {\n" + 
			"	Zork z;\n" +
			"}\n" + 
			"\n" + 
			"public class X {\n" + 
			"    static C.B<Double> c = new C().new B<Double>();\n" + 
			"\n" + 
			"    public static void main(String[] args) {\n" + 
			"        C.B<String> temp = new C().new B<String>();\n" + 
			"        String s = temp.getValue();\n" + 
			"        System.out.println(s);\n" + 
			"        foo(bar());\n" + 
			"    }\n" + 
			"\n" + 
			"    static C.B<? extends Number> bar() {\n" + 
			"        return new C().new B<Integer>();\n" + 
			"    }\n" + 
			"\n" + 
			"    static void foo(C.B<?> arg) {\n" + 
			"        Object o = arg.getValue();\n" + 
			"        Double d = c.getValue();\n" + 
			"        System.out.println(o);\n" + 
			"        System.out.println(d);\n" + 
			"    }\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 11)\n" + 
		"	Zork z;\n" + 
		"	^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 15)\n" + 
		"	static C.B<Double> c = new C().new B<Double>();\n" + 
		"	                           ^\n" + 
		"C is a raw type. References to generic type C<T> should be parameterized\n" + 
		"----------\n" + 
		"3. WARNING in X.java (at line 18)\n" + 
		"	C.B<String> temp = new C().new B<String>();\n" + 
		"	                       ^\n" + 
		"C is a raw type. References to generic type C<T> should be parameterized\n" + 
		"----------\n" + 
		"4. WARNING in X.java (at line 25)\n" + 
		"	return new C().new B<Integer>();\n" + 
		"	           ^\n" + 
		"C is a raw type. References to generic type C<T> should be parameterized\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=183216 - variation
public void test1126() {
	this.runConformTest(
		new String[] {
			"X.java",
			"class A {\n" + 
			"    class B<T> {\n" + 
			"        T t;\n" + 
			"        T getValue() {\n" + 
			"            return t;\n" + 
			"        }\n" + 
			"    }\n" + 
			"}\n" + 
			"\n" + 
			"public class X {\n" + 
			"    static A.B<Double> c = new A().new B<Double>();\n" + 
			"\n" + 
			"    public static void main(String[] args) {\n" + 
			"        A.B<String> temp = new A().new B<String>();\n" + 
			"        String s = temp.getValue();\n" + 
			"        System.out.print(s);\n" + 
			"        foo(bar());\n" + 
			"    }\n" + 
			"\n" + 
			"    static A.B<? extends Number> bar() {\n" + 
			"        return new A().new B<Integer>();\n" + 
			"    }\n" + 
			"\n" + 
			"    static void foo(A.B<?> arg) {\n" + 
			"        Object o = arg.getValue();\n" + 
			"        Double d = c.getValue();\n" + 
			"        System.out.print(o);\n" + 
			"        System.out.print(d);\n" + 
			"    }\n" + 
			"}\n", // =================
		},
		"nullnullnull");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=183216 - variation
public void test1127() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"class A<E> {\n" + 
			"    class B<T> {\n" + 
			"        T t;\n" + 
			"        T getValue() {\n" + 
			"            return t;\n" + 
			"        }\n" + 
			"    }\n" + 
			"}\n" + 
			"\n" + 
			"class C<T> extends A<T> {\n" + 
			"}\n" + 
			"\n" + 
			"public class X {\n" + 
			"    static C.B<Double> c = new C().new B<Double>();\n" + 
			"\n" + 
			"    public static void main(String[] args) {\n" + 
			"        C.B<String> temp = new C().new B<String>();\n" + 
			"        String s = temp.getValue();\n" + 
			"        System.out.println(s);\n" + 
			"        foo(bar());\n" + 
			"    }\n" + 
			"\n" + 
			"    static C.B<? extends Number> bar() {\n" + 
			"        return new C().new B<Integer>();\n" + 
			"    }\n" + 
			"\n" + 
			"    static void foo(C.B<?> arg) {\n" + 
			"        Object o = arg.getValue();\n" + 
			"        Double d = c.getValue();\n" + 
			"        System.out.println(o);\n" + 
			"        System.out.println(d);\n" + 
			"    }\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 14)\n" + 
		"	static C.B<Double> c = new C().new B<Double>();\n" + 
		"	       ^^^\n" + 
		"The member type A.B<Double> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 14)\n" + 
		"	static C.B<Double> c = new C().new B<Double>();\n" + 
		"	                           ^\n" + 
		"C is a raw type. References to generic type C<T> should be parameterized\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 14)\n" + 
		"	static C.B<Double> c = new C().new B<Double>();\n" + 
		"	                                   ^\n" + 
		"The member type A.B<Double> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n" + 
		"4. ERROR in X.java (at line 17)\n" + 
		"	C.B<String> temp = new C().new B<String>();\n" + 
		"	^^^\n" + 
		"The member type A.B<String> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n" + 
		"5. WARNING in X.java (at line 17)\n" + 
		"	C.B<String> temp = new C().new B<String>();\n" + 
		"	                       ^\n" + 
		"C is a raw type. References to generic type C<T> should be parameterized\n" + 
		"----------\n" + 
		"6. ERROR in X.java (at line 17)\n" + 
		"	C.B<String> temp = new C().new B<String>();\n" + 
		"	                               ^\n" + 
		"The member type A.B<String> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n" + 
		"7. ERROR in X.java (at line 23)\n" + 
		"	static C.B<? extends Number> bar() {\n" + 
		"	       ^^^\n" + 
		"The member type A.B<? extends Number> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n" + 
		"8. WARNING in X.java (at line 24)\n" + 
		"	return new C().new B<Integer>();\n" + 
		"	           ^\n" + 
		"C is a raw type. References to generic type C<T> should be parameterized\n" + 
		"----------\n" + 
		"9. ERROR in X.java (at line 24)\n" + 
		"	return new C().new B<Integer>();\n" + 
		"	                   ^\n" + 
		"The member type A.B<Integer> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n" + 
		"10. ERROR in X.java (at line 27)\n" + 
		"	static void foo(C.B<?> arg) {\n" + 
		"	                ^^^\n" + 
		"The member type A.B<?> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=183216 - variation
public void test1128() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"class A<T> {\n" + 
			"	class Member<U> {}\n" + 
			"}\n" + 
			"\n" + 
			"public class X extends A {\n" + 
			"	void foo() {\n" + 
			"		new Member<String>();\n" + 
			"		new X().new Member<String>();\n" + 
			"	}\n" + 
			"}\n", // =================
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 5)\n" + 
		"	public class X extends A {\n" + 
		"	                       ^\n" + 
		"A is a raw type. References to generic type A<T> should be parameterized\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 7)\n" + 
		"	new Member<String>();\n" + 
		"	    ^^^^^^\n" + 
		"The member type A.Member<String> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n" + 
		"3. ERROR in X.java (at line 8)\n" + 
		"	new X().new Member<String>();\n" + 
		"	            ^^^^^^\n" + 
		"The member type A.Member<String> must be qualified with a parameterized type, since it is not static\n" + 
		"----------\n");
}
}

Return to bug 183216

Lines 218-228 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/ParameterizedQualifiedTypeReference.java (-6 / +10 lines)
218	return null;	218	return null;
219	}	219	}
220	// check parameterizing non-static member type of raw type	220	// check parameterizing non-static member type of raw type
221	if (typeIsConsistent && !currentType.isStatic() && qualifiedType != null && qualifiedType.isRawType()) {	221	if (typeIsConsistent && !currentType.isStatic()) {
222	scope.problemReporter().rawMemberTypeCannotBeParameterized(	222	ReferenceBinding actualEnclosing = currentType.enclosingType();
223	this, scope.environment().createRawType((ReferenceBinding)currentType.erasure(), qualifiedType), argTypes);	223	if (actualEnclosing != null && actualEnclosing.isRawType()) {
224	typeIsConsistent = false;	224	scope.problemReporter().rawMemberTypeCannotBeParameterized(
225	}	225	this, scope.environment().createRawType((ReferenceBinding)currentType.erasure(), actualEnclosing), argTypes);
		226	typeIsConsistent = false;
		227	}
		228	}
226	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType((ReferenceBinding)currentType.erasure(), argTypes, qualifiedType);	229	ParameterizedTypeBinding parameterizedType = scope.environment().createParameterizedType((ReferenceBinding)currentType.erasure(), argTypes, qualifiedType);
227	// check argument type compatibility	230	// check argument type compatibility
228	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution	231	if (checkBounds) // otherwise will do it in Scope.connectTypeVariables() or generic method resolution
Lines 247-254 Link Here
247	}	250	}
248	if (isTypeUseDeprecated(qualifiedType, scope))	251	if (isTypeUseDeprecated(qualifiedType, scope))
249	reportDeprecatedType(qualifiedType, scope);	252	reportDeprecatedType(qualifiedType, scope);
		253	this.resolvedType = qualifiedType;
250	}	254	}
251	this.resolvedType = qualifiedType;	255	// this.resolvedType = qualifiedType;
252	// array type ?	256	// array type ?
253	if (this.dimensions > 0) {	257	if (this.dimensions > 0) {
254	if (dimensions > 255)	258	if (dimensions > 255)

Lines 37384-37387 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java (+224 lines)
37384	"Type mismatch: cannot convert from element type Object to Map.Entry<String,String>\n" +	37384	"Type mismatch: cannot convert from element type Object to Map.Entry<String,String>\n" +
37385	"----------\n");	37385	"----------\n");
37386	}	37386	}
		37387	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=183216
		37388	public void test1125() {
		37389	this.runNegativeTest(
		37390	new String[] {
		37391	"X.java",
		37392	"class A {\n" +
		37393	" class B<T> {\n" +
		37394	" T t;\n" +
		37395	" T getValue() {\n" +
		37396	" return t;\n" +
		37397	" }\n" +
		37398	" }\n" +
		37399	"}\n" +
		37400	"\n" +
		37401	"class C<T> extends A {\n" +
		37402	" Zork z;\n" +
		37403	"}\n" +
		37404	"\n" +
		37405	"public class X {\n" +
		37406	" static C.B<Double> c = new C().new B<Double>();\n" +
		37407	"\n" +
		37408	" public static void main(String[] args) {\n" +
		37409	" C.B<String> temp = new C().new B<String>();\n" +
		37410	" String s = temp.getValue();\n" +
		37411	" System.out.println(s);\n" +
		37412	" foo(bar());\n" +
		37413	" }\n" +
		37414	"\n" +
		37415	" static C.B<? extends Number> bar() {\n" +
		37416	" return new C().new B<Integer>();\n" +
		37417	" }\n" +
		37418	"\n" +
		37419	" static void foo(C.B<?> arg) {\n" +
		37420	" Object o = arg.getValue();\n" +
		37421	" Double d = c.getValue();\n" +
		37422	" System.out.println(o);\n" +
		37423	" System.out.println(d);\n" +
		37424	" }\n" +
		37425	"}\n", // =================
		37426	},
		37427	"----------\n" +
		37428	"1. ERROR in X.java (at line 11)\n" +
		37429	" Zork z;\n" +
		37430	" ^^^^\n" +
		37431	"Zork cannot be resolved to a type\n" +
		37432	"----------\n" +
		37433	"2. WARNING in X.java (at line 15)\n" +
		37434	" static C.B<Double> c = new C().new B<Double>();\n" +
		37435	" ^\n" +
		37436	"C is a raw type. References to generic type C<T> should be parameterized\n" +
		37437	"----------\n" +
		37438	"3. WARNING in X.java (at line 18)\n" +
		37439	" C.B<String> temp = new C().new B<String>();\n" +
		37440	" ^\n" +
		37441	"C is a raw type. References to generic type C<T> should be parameterized\n" +
		37442	"----------\n" +
		37443	"4. WARNING in X.java (at line 25)\n" +
		37444	" return new C().new B<Integer>();\n" +
		37445	" ^\n" +
		37446	"C is a raw type. References to generic type C<T> should be parameterized\n" +
		37447	"----------\n");
		37448	}
		37449	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=183216 - variation
		37450	public void test1126() {
37451	this.runConformTest(
37452	new String[] {
37453	"X.java",
37454	"class A {\n" +
37455	" class B<T> {\n" +
37456	" T t;\n" +
37457	" T getValue() {\n" +
37458	" return t;\n" +
37459	" }\n" +
37460	" }\n" +
37461	"}\n" +
37462	"\n" +
37463	"public class X {\n" +
37464	" static A.B<Double> c = new A().new B<Double>();\n" +
37465	"\n" +
37466	" public static void main(String[] args) {\n" +
37467	" A.B<String> temp = new A().new B<String>();\n" +
37468	" String s = temp.getValue();\n" +
37469	" System.out.print(s);\n" +
37470	" foo(bar());\n" +
37471	" }\n" +
37472	"\n" +
37473	" static A.B<? extends Number> bar() {\n" +
37474	" return new A().new B<Integer>();\n" +
37475	" }\n" +
37476	"\n" +
37477	" static void foo(A.B<?> arg) {\n" +
37478	" Object o = arg.getValue();\n" +
37479	" Double d = c.getValue();\n" +
37480	" System.out.print(o);\n" +
37481	" System.out.print(d);\n" +
37482	" }\n" +
37483	"}\n", // =================
37484	},
37485	"nullnullnull");
37486	}
37487	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=183216 - variation
37488	public void test1127() {
37489	this.runNegativeTest(
37490	new String[] {
37491	"X.java",
37492	"class A<E> {\n" +
37493	" class B<T> {\n" +
37494	" T t;\n" +
37495	" T getValue() {\n" +
37496	" return t;\n" +
37497	" }\n" +
37498	" }\n" +
37499	"}\n" +
37500	"\n" +
37501	"class C<T> extends A<T> {\n" +
37502	"}\n" +
37503	"\n" +
37504	"public class X {\n" +
37505	" static C.B<Double> c = new C().new B<Double>();\n" +
37506	"\n" +
37507	" public static void main(String[] args) {\n" +
37508	" C.B<String> temp = new C().new B<String>();\n" +
37509	" String s = temp.getValue();\n" +
37510	" System.out.println(s);\n" +
37511	" foo(bar());\n" +
37512	" }\n" +
37513	"\n" +
37514	" static C.B<? extends Number> bar() {\n" +
37515	" return new C().new B<Integer>();\n" +
37516	" }\n" +
37517	"\n" +
37518	" static void foo(C.B<?> arg) {\n" +
37519	" Object o = arg.getValue();\n" +
37520	" Double d = c.getValue();\n" +
37521	" System.out.println(o);\n" +
37522	" System.out.println(d);\n" +
37523	" }\n" +
37524	"}\n", // =================
37525	},
37526	"----------\n" +
37527	"1. ERROR in X.java (at line 14)\n" +
37528	" static C.B<Double> c = new C().new B<Double>();\n" +
37529	" ^^^\n" +
37530	"The member type A.B<Double> must be qualified with a parameterized type, since it is not static\n" +
37531	"----------\n" +
37532	"2. WARNING in X.java (at line 14)\n" +
37533	" static C.B<Double> c = new C().new B<Double>();\n" +
37534	" ^\n" +
37535	"C is a raw type. References to generic type C<T> should be parameterized\n" +
37536	"----------\n" +
37537	"3. ERROR in X.java (at line 14)\n" +
37538	" static C.B<Double> c = new C().new B<Double>();\n" +
37539	" ^\n" +
37540	"The member type A.B<Double> must be qualified with a parameterized type, since it is not static\n" +
37541	"----------\n" +
37542	"4. ERROR in X.java (at line 17)\n" +
37543	" C.B<String> temp = new C().new B<String>();\n" +
37544	" ^^^\n" +
37545	"The member type A.B<String> must be qualified with a parameterized type, since it is not static\n" +
37546	"----------\n" +
37547	"5. WARNING in X.java (at line 17)\n" +
37548	" C.B<String> temp = new C().new B<String>();\n" +
37549	" ^\n" +
37550	"C is a raw type. References to generic type C<T> should be parameterized\n" +
37551	"----------\n" +
37552	"6. ERROR in X.java (at line 17)\n" +
37553	" C.B<String> temp = new C().new B<String>();\n" +
37554	" ^\n" +
37555	"The member type A.B<String> must be qualified with a parameterized type, since it is not static\n" +
37556	"----------\n" +
37557	"7. ERROR in X.java (at line 23)\n" +
37558	" static C.B<? extends Number> bar() {\n" +
37559	" ^^^\n" +
37560	"The member type A.B<? extends Number> must be qualified with a parameterized type, since it is not static\n" +
37561	"----------\n" +
37562	"8. WARNING in X.java (at line 24)\n" +
37563	" return new C().new B<Integer>();\n" +
37564	" ^\n" +
37565	"C is a raw type. References to generic type C<T> should be parameterized\n" +
37566	"----------\n" +
37567	"9. ERROR in X.java (at line 24)\n" +
37568	" return new C().new B<Integer>();\n" +
37569	" ^\n" +
37570	"The member type A.B<Integer> must be qualified with a parameterized type, since it is not static\n" +
37571	"----------\n" +
37572	"10. ERROR in X.java (at line 27)\n" +
37573	" static void foo(C.B<?> arg) {\n" +
37574	" ^^^\n" +
37575	"The member type A.B<?> must be qualified with a parameterized type, since it is not static\n" +
37576	"----------\n");
37577	}
37578	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=183216 - variation
37579	public void test1128() {
37580	this.runNegativeTest(
37581	new String[] {
37582	"X.java",
37583	"class A<T> {\n" +
37584	" class Member<U> {}\n" +
37585	"}\n" +
37586	"\n" +
37587	"public class X extends A {\n" +
37588	" void foo() {\n" +
37589	" new Member<String>();\n" +
37590	" new X().new Member<String>();\n" +
37591	" }\n" +
37592	"}\n", // =================
37593	},
37594	"----------\n" +
37595	"1. WARNING in X.java (at line 5)\n" +
37596	" public class X extends A {\n" +
37597	" ^\n" +
37598	"A is a raw type. References to generic type A<T> should be parameterized\n" +
37599	"----------\n" +
37600	"2. ERROR in X.java (at line 7)\n" +
37601	" new Member<String>();\n" +
37602	" ^^^^^^\n" +
37603	"The member type A.Member<String> must be qualified with a parameterized type, since it is not static\n" +
37604	"----------\n" +
37605	"3. ERROR in X.java (at line 8)\n" +
37606	" new X().new Member<String>();\n" +
37607	" ^^^^^^\n" +
37608	"The member type A.Member<String> must be qualified with a parameterized type, since it is not static\n" +
37609	"----------\n");
37610	}
37387	}	37611	}