Attachment 123586 Details for Bug 262209 – Proposed patch and testcase for 3.4.2

[patch] Proposed patch and testcase for 3.4.2

ambigpatch.txt (text/plain), 21.04 KB, created by Kent Johnson

on 2009-01-23 14:57:58 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Kent Johnson

Created: 2009-01-23 14:57:58 EST

Size: 21.04 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.jdt.core
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java,v
>retrieving revision 1.100.2.3
>diff -u -r1.100.2.3 MethodBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java	5 Dec 2008 16:01:20 -0000	1.100.2.3
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java	23 Jan 2009 19:48:21 -0000
>@@ -148,6 +148,29 @@
> 			return false;
> 	return true;
> }
>+MethodBinding asRawMethod(LookupEnvironment env) {
>+	if (this.typeVariables == Binding.NO_TYPE_VARIABLES) return this;
>+
>+	// substitute type arguments with raw types
>+	int length = this.typeVariables.length;
>+	TypeBinding[] arguments = new TypeBinding[length];
>+	for (int i = 0; i < length; i++) {
>+		TypeVariableBinding var = this.typeVariables[i];
>+		if (var.boundsCount() <= 1) {
>+			arguments[i] = env.convertToRawType(var.upperBound(), false /*do not force conversion of enclosing types*/);
>+		} else {
>+			// use an intersection type to retain full bound information if more than 1 bound
>+			TypeBinding rawSuperclass = env.convertToRawType(var.superclass(), false);
>+			TypeBinding[] itsSuperinterfaces = var.superInterfaces();
>+			int superLength = itsSuperinterfaces.length;
>+			TypeBinding[] rawSuperinterfaces = new TypeBinding[superLength];
>+			for (int s = 0; s < superLength; s++)
>+				rawSuperinterfaces[s] = env.convertToRawType(itsSuperinterfaces[s], false);
>+			arguments[i] = env.createWildcard(null, 0, rawSuperclass, rawSuperinterfaces, org.eclipse.jdt.internal.compiler.ast.Wildcard.EXTENDS);
>+		}
>+	}
>+	return env.createParameterizedGenericMethod(this, arguments);
>+}
> /* Answer true if the receiver is visible to the type provided by the scope.
> * InvocationSite implements isSuperAccess() to provide additional information
> * if the receiver is protected.
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java,v
>retrieving revision 1.64
>diff -u -r1.64 ParameterizedGenericMethodBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java	27 May 2008 22:21:12 -0000	1.64
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java	23 Jan 2009 19:48:21 -0000
>@@ -11,7 +11,6 @@
> package org.eclipse.jdt.internal.compiler.lookup;
> 
> import org.eclipse.jdt.internal.compiler.ast.MessageSend;
>-import org.eclipse.jdt.internal.compiler.ast.Wildcard;
> 
> /**
>  * Binding denoting a generic method after type parameter substitutions got performed.
>@@ -503,22 +502,8 @@
> 	 * @see org.eclipse.jdt.internal.compiler.lookup.MethodBinding#tiebreakMethod()
> 	 */
> 	public MethodBinding tiebreakMethod() {
>-		if (this.tiebreakMethod == null) {
>-			TypeVariableBinding[] originalVariables = this.originalMethod.typeVariables;
>-			int length = originalVariables.length;
>-			TypeBinding[] newArguments = new TypeBinding[length];
>-			for (int i = 0; i < length; i++) {
>-				TypeVariableBinding originalVariable = originalVariables[i];
>-				if (originalVariable.boundsCount() <= 1) {
>-					newArguments[i] = this.environment.convertToRawType(originalVariable.upperBound(), false /*do not force conversion of enclosing types*/);
>-				} else {
>-					newArguments[i] = this.environment.convertToRawType(
>-							// use an intersection type to retain full bound information
>-							this.environment.createWildcard(null, 0, originalVariable.superclass(), originalVariable.superInterfaces(), Wildcard.EXTENDS), false /*do not force conversion of enclosing types*/);
>-				}
>-			}
>-			this.tiebreakMethod = this.environment.createParameterizedGenericMethod(this.originalMethod, newArguments);
>-		} 
>+		if (this.tiebreakMethod == null)
>+			this.tiebreakMethod = this.originalMethod.asRawMethod(this.environment);
> 		return this.tiebreakMethod;
> 	}
> }
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java,v
>retrieving revision 1.65.2.1
>diff -u -r1.65.2.1 TypeVariableBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java	23 Oct 2008 07:14:42 -0000	1.65.2.1
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java	23 Jan 2009 19:48:22 -0000
>@@ -293,7 +293,19 @@
> 			return this.superInterfaces.length;
> 		}
> 	}
>-	
>+
>+	boolean hasOnlyRawBounds() {
>+		if (this.superclass != null && !this.superclass.isRawType())
>+			return false;
>+
>+		if (this.superInterfaces != null)
>+			for (int i = 0, l = this.superInterfaces.length; i < l; i++)
>+		   		if (!this.superInterfaces[i].isRawType())
>+		   			return false;
>+
>+		return true;
>+	}
>+
> 	/**
> 	 * Returns true if the type variable is directly bound to a given type
> 	 */
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java,v
>retrieving revision 1.333.2.6
>diff -u -r1.333.2.6 Scope.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java	5 Dec 2008 16:01:20 -0000	1.333.2.6
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java	23 Jan 2009 19:48:22 -0000
>@@ -2652,27 +2652,30 @@
> 		int oneParamsLength = oneParams.length;
> 		int twoParamsLength = twoParams.length;
> 		if (oneParamsLength == twoParamsLength) {
>-			for (int i = 0; i < oneParamsLength; i++) {
>+			next : for (int i = 0; i < oneParamsLength; i++) {
> 				TypeBinding oneParam = oneParams[i];
> 				TypeBinding twoParam = twoParams[i];
>-				if (oneParam == twoParam) {
>-					if (twoParam.leafComponentType().isRawType()) {
>-						// must detect & reject this case
>-						// when Y<U> extends X<U>
>-						// void foo(Y y) {}
>-						// <T extends X<Object>> void foo(T t) {}
>-						// foo(T) will show up as foo(Y#RAW) and not foo(X#RAW)
>-						// Y#RAW is not more specific than a rawified X<T>
>-						if (oneParam == one.original().parameters[i]
>-								&&  twoParam.leafComponentType().erasure() != two.original().parameters[i].leafComponentType().erasure()) {
>-							return false;
>-						}
>-					}
>-				} else if (oneParam.isCompatibleWith(twoParam)) {
>-					if (oneParam.leafComponentType().isRawType()) {
>-						// A#RAW is not more specific than a rawified A<T>
>-						if (oneParam.needsUncheckedConversion(two.declaringClass.isRawType() ? twoParam : two.original().parameters[i]))
>-							return false;
>+				if (oneParam == twoParam || oneParam.isCompatibleWith(twoParam)) {
>+					if (two.declaringClass.isRawType()) continue next;
>+
>+					TypeBinding originalOneParam = one.original().parameters[i].leafComponentType();
>+					switch (originalOneParam.kind()) {
>+					   	case Binding.TYPE_PARAMETER :
>+					   		if (!((TypeVariableBinding) originalOneParam).upperBound().isRawType()) break;
>+					   		//$FALL-THROUGH$
>+					   	case Binding.RAW_TYPE:
>+					   		// originalOneParam is RAW so it cannot be more specific than a wildcard or parameterized type
>+							TypeBinding originalTwoParam = two.original().parameters[i].leafComponentType();
>+							switch (originalTwoParam.kind()) {
>+							   	case Binding.TYPE_PARAMETER :
>+							   		if (((TypeVariableBinding) originalTwoParam).hasOnlyRawBounds())
>+								   		continue next;
>+								   	return false;
>+							   	case Binding.WILDCARD_TYPE :
>+							   	case Binding.INTERSECTION_TYPE:
>+							   	case Binding.PARAMETERIZED_TYPE :
>+							   		return false;
>+							}
> 					}
> 				} else {
> 					if (i == oneParamsLength - 1 && one.isVarargs() && two.isVarargs()) {
>Index: compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java,v
>retrieving revision 1.68.2.1
>diff -u -r1.68.2.1 WildcardBinding.java
>--- compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java	23 Oct 2008 07:14:42 -0000	1.68.2.1
>+++ compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java	23 Jan 2009 19:48:22 -0000
>@@ -68,17 +68,17 @@
> 	        case Wildcard.UNBOUND :
> 	            return true;
> 	        case Wildcard.EXTENDS :
>-	            if (argumentType.isCompatibleWith(this.bound)) return true;
>+	            if (!argumentType.isCompatibleWith(this.bound)) return false;
> 	            // check other bounds (lub scenario)
>-            	for (int i = 0, length = this.otherBounds == null ? 0 : this.otherBounds.length; i < length; i++) {
>-            		if (argumentType.isCompatibleWith(this.otherBounds[i])) return true;
>-            	}
>-            	return false;
>+	        	for (int i = 0, length = this.otherBounds == null ? 0 : this.otherBounds.length; i < length; i++) {
>+	        		if (!argumentType.isCompatibleWith(this.otherBounds[i])) return false;
>+	        	}
>+	        	return true;
> 	        default: // SUPER
> 	        	// ? super Exception   ok for:  IOException, since it would be ok for (Exception)ioException
> 	            return argumentType.isCompatibleWith(this.bound);
> 	    }
>-    }
>+	}
> 	/**
> 	 * @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#canBeInstantiated()
> 	 */
>#P org.eclipse.jdt.core.tests.compiler
>Index: src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java,v
>retrieving revision 1.52.2.1
>diff -u -r1.52.2.1 AmbiguousMethodTest.java
>--- src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java	4 Nov 2008 17:04:18 -0000	1.52.2.1
>+++ src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java	23 Jan 2009 19:48:24 -0000
>@@ -940,6 +940,321 @@
> 			false
> 		);
> 	}
>+	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=262209
>+	public void test014i() {
>+		this.runNegativeTest(
>+			new String[] {
>+				"X.java",
>+				"interface I<T> {}\n" +
>+				"interface J<T> extends I<T> {}\n" +
>+				"\n" +
>+				"class X {\n" +
>+				"	void a(G x) {}\n" +
>+				"	<T extends C, S extends F<T>> void a(S x) {}\n" +
>+				"\n" +
>+				"	void b(G x) {}\n" +
>+				"	void b(F x) {}\n" +
>+				"\n" +
>+				"	void c(G x) {}\n" +
>+				"	void c(F<?> x) {}\n" +
>+				"\n" +
>+				"	void d(G x) {}\n" +
>+				"	void d(F<C> x) {}\n" +
>+				"\n" +
>+				"	void e(G x) {}\n" +
>+				"	<T extends C> void e(F<T> x) {}\n" +
>+				"\n" +
>+				"	void f(G x) {}\n" +
>+				"	<S extends F> void f(S x) {}\n" +
>+				"\n" +
>+				"	void g(G x) {}\n" +
>+				"	<S extends F & J<S>> void g(S x) {}\n" +
>+				"\n" +
>+				"	<T extends G> void a2(T x) {}\n" +
>+				"	<T extends C, S extends F<T>> void a2(S x) {}\n" +
>+				"\n" +
>+				"	<T extends G> void b2(T x) {}\n" +
>+				"	void b2(F x) {}\n" +
>+				"\n" +
>+				"	<T extends G> void c2(T x) {}\n" +
>+				"	void c2(F<?> x) {}\n" +
>+				"\n" +
>+				"	<T extends G> void d2(T x) {}\n" +
>+				"	void d2(F<C> x) {}\n" +
>+				"\n" +
>+				"	<T extends G> void e2(T x) {}\n" +
>+				"	<T extends C> void e2(F<T> x) {}\n" +
>+				"\n" +
>+				"	<T extends G> void f2(T x) {}\n" +
>+				"	<S extends F & J> void f2(S x) {}\n" +
>+				"\n" +
>+				"	<T extends G> void g2(T x) {}\n" +
>+				"	<S extends F & J<S>> void g2(S x) {}\n" +
>+				"\n" +
>+				"	void test() {\n" +
>+				"		X x = new X();\n" +
>+				"		H<C> h = null;\n" +
>+				"		H hraw = null;\n" +
>+				"\n" +
>+				"		x.a(h);\n" +
>+				"		x.a(hraw);\n" +
>+				"\n" +
>+				"		x.b(h);\n" +
>+				"		x.b(hraw);\n" +
>+				"\n" +
>+				"		x.c(h);\n" +
>+				"		x.c(hraw);\n" +
>+				"\n" +
>+				"		x.d(h);\n" +
>+				"		x.d(hraw);\n" +
>+				"\n" +
>+				"		x.e(h);\n" +
>+				"		x.e(hraw);\n" +
>+				"\n" +
>+				"		x.f(h);\n" +
>+				"		x.f(hraw);\n" +
>+				"\n" +
>+				"		x.g(h);\n" +
>+				"		x.g(hraw);\n" +
>+				"\n" +
>+				"		x.a2(h);\n" +
>+				"		x.a2(hraw);\n" +
>+				"\n" +
>+				"		x.b2(h);	\n" +
>+				"		x.b2(hraw);\n" +
>+				"\n" +
>+				"		x.c2(h);\n" +
>+				"		x.c2(hraw);\n" +
>+				"\n" +
>+				"		x.d2(h);\n" +
>+				"		x.d2(hraw);\n" +
>+				"\n" +
>+				"		x.e2(h);\n" +
>+				"		x.e2(hraw);\n" +
>+				"\n" +
>+				"		x.f2(h);\n" +
>+				"		x.f2(hraw);\n" +
>+				"\n" +
>+				"		x.g2(h);	\n" +
>+				"		x.g2(hraw);\n" +
>+				"	}\n" +
>+				"}\n" +
>+				"\n" +
>+				"class A {}\n" +
>+				"class B extends A {}\n" +
>+				"class C extends B implements I {}\n" +
>+				"class F<T1> {} \n" +
>+				"class G<T2> extends F<T2> implements J<T2> {}\n" +
>+				"class H<T3> extends G<T3> {}\n"
>+			},
>+			"----------\n" + 
>+			"1. WARNING in X.java (at line 5)\n" + 
>+			"	void a(G x) {}\n" + 
>+			"	       ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"2. WARNING in X.java (at line 8)\n" + 
>+			"	void b(G x) {}\n" + 
>+			"	       ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"3. WARNING in X.java (at line 9)\n" + 
>+			"	void b(F x) {}\n" + 
>+			"	       ^\n" + 
>+			"F is a raw type. References to generic type F<T1> should be parameterized\n" + 
>+			"----------\n" + 
>+			"4. WARNING in X.java (at line 11)\n" + 
>+			"	void c(G x) {}\n" + 
>+			"	       ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"5. WARNING in X.java (at line 14)\n" + 
>+			"	void d(G x) {}\n" + 
>+			"	       ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"6. WARNING in X.java (at line 17)\n" + 
>+			"	void e(G x) {}\n" + 
>+			"	       ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"7. WARNING in X.java (at line 20)\n" + 
>+			"	void f(G x) {}\n" + 
>+			"	       ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"8. WARNING in X.java (at line 21)\n" + 
>+			"	<S extends F> void f(S x) {}\n" + 
>+			"	           ^\n" + 
>+			"F is a raw type. References to generic type F<T1> should be parameterized\n" + 
>+			"----------\n" + 
>+			"9. WARNING in X.java (at line 23)\n" + 
>+			"	void g(G x) {}\n" + 
>+			"	       ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"10. WARNING in X.java (at line 24)\n" + 
>+			"	<S extends F & J<S>> void g(S x) {}\n" + 
>+			"	           ^\n" + 
>+			"F is a raw type. References to generic type F<T1> should be parameterized\n" + 
>+			"----------\n" + 
>+			"11. WARNING in X.java (at line 26)\n" + 
>+			"	<T extends G> void a2(T x) {}\n" + 
>+			"	           ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"12. WARNING in X.java (at line 29)\n" + 
>+			"	<T extends G> void b2(T x) {}\n" + 
>+			"	           ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"13. WARNING in X.java (at line 30)\n" + 
>+			"	void b2(F x) {}\n" + 
>+			"	        ^\n" + 
>+			"F is a raw type. References to generic type F<T1> should be parameterized\n" + 
>+			"----------\n" + 
>+			"14. WARNING in X.java (at line 32)\n" + 
>+			"	<T extends G> void c2(T x) {}\n" + 
>+			"	           ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"15. WARNING in X.java (at line 35)\n" + 
>+			"	<T extends G> void d2(T x) {}\n" + 
>+			"	           ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"16. WARNING in X.java (at line 38)\n" + 
>+			"	<T extends G> void e2(T x) {}\n" + 
>+			"	           ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"17. WARNING in X.java (at line 41)\n" + 
>+			"	<T extends G> void f2(T x) {}\n" + 
>+			"	           ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"18. WARNING in X.java (at line 42)\n" + 
>+			"	<S extends F & J> void f2(S x) {}\n" + 
>+			"	           ^\n" + 
>+			"F is a raw type. References to generic type F<T1> should be parameterized\n" + 
>+			"----------\n" + 
>+			"19. WARNING in X.java (at line 42)\n" + 
>+			"	<S extends F & J> void f2(S x) {}\n" + 
>+			"	               ^\n" + 
>+			"J is a raw type. References to generic type J<T> should be parameterized\n" + 
>+			"----------\n" + 
>+			"20. WARNING in X.java (at line 44)\n" + 
>+			"	<T extends G> void g2(T x) {}\n" + 
>+			"	           ^\n" + 
>+			"G is a raw type. References to generic type G<T2> should be parameterized\n" + 
>+			"----------\n" + 
>+			"21. WARNING in X.java (at line 45)\n" + 
>+			"	<S extends F & J<S>> void g2(S x) {}\n" + 
>+			"	           ^\n" + 
>+			"F is a raw type. References to generic type F<T1> should be parameterized\n" + 
>+			"----------\n" + 
>+			"22. WARNING in X.java (at line 50)\n" + 
>+			"	H hraw = null;\n" + 
>+			"	^\n" + 
>+			"H is a raw type. References to generic type H<T3> should be parameterized\n" + 
>+			"----------\n" + 
>+			"23. ERROR in X.java (at line 52)\n" + 
>+			"	x.a(h);\n" + 
>+			"	  ^\n" + 
>+			"The method a(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"24. ERROR in X.java (at line 53)\n" + 
>+			"	x.a(hraw);\n" + 
>+			"	  ^\n" + 
>+			"The method a(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"25. ERROR in X.java (at line 58)\n" + 
>+			"	x.c(h);\n" + 
>+			"	  ^\n" + 
>+			"The method c(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"26. ERROR in X.java (at line 59)\n" + 
>+			"	x.c(hraw);\n" + 
>+			"	  ^\n" + 
>+			"The method c(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"27. ERROR in X.java (at line 61)\n" + 
>+			"	x.d(h);\n" + 
>+			"	  ^\n" + 
>+			"The method d(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"28. ERROR in X.java (at line 62)\n" + 
>+			"	x.d(hraw);\n" + 
>+			"	  ^\n" + 
>+			"The method d(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"29. ERROR in X.java (at line 64)\n" + 
>+			"	x.e(h);\n" + 
>+			"	  ^\n" + 
>+			"The method e(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"30. ERROR in X.java (at line 65)\n" + 
>+			"	x.e(hraw);\n" + 
>+			"	  ^\n" + 
>+			"The method e(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"31. ERROR in X.java (at line 71)\n" + 
>+			"	x.g(hraw);\n" + 
>+			"	  ^\n" + 
>+			"The method g(G) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"32. ERROR in X.java (at line 73)\n" + 
>+			"	x.a2(h);\n" + 
>+			"	  ^^\n" + 
>+			"The method a2(H<C>) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"33. ERROR in X.java (at line 74)\n" + 
>+			"	x.a2(hraw);\n" + 
>+			"	  ^^\n" + 
>+			"The method a2(H) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"34. ERROR in X.java (at line 79)\n" + 
>+			"	x.c2(h);\n" + 
>+			"	  ^^\n" + 
>+			"The method c2(H<C>) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"35. ERROR in X.java (at line 80)\n" + 
>+			"	x.c2(hraw);\n" + 
>+			"	  ^^\n" + 
>+			"The method c2(H) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"36. ERROR in X.java (at line 82)\n" + 
>+			"	x.d2(h);\n" + 
>+			"	  ^^\n" + 
>+			"The method d2(H<C>) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"37. ERROR in X.java (at line 83)\n" + 
>+			"	x.d2(hraw);\n" + 
>+			"	  ^^\n" + 
>+			"The method d2(H) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"38. ERROR in X.java (at line 85)\n" + 
>+			"	x.e2(h);\n" + 
>+			"	  ^^\n" + 
>+			"The method e2(H<C>) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"39. ERROR in X.java (at line 86)\n" + 
>+			"	x.e2(hraw);\n" + 
>+			"	  ^^\n" + 
>+			"The method e2(H) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"40. ERROR in X.java (at line 92)\n" + 
>+			"	x.g2(hraw);\n" + 
>+			"	  ^^\n" + 
>+			"The method g2(H) is ambiguous for the type X\n" + 
>+			"----------\n" + 
>+			"41. WARNING in X.java (at line 98)\n" + 
>+			"	class C extends B implements I {}\n" + 
>+			"	                             ^\n" + 
>+			"I is a raw type. References to generic type I<T> should be parameterized\n" + 
>+			"----------\n"
>+		);
>+	}
> 	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=79798
> 	public void test015() {
> 		this.runConformTest(

Actions: View | Diff

Attachments on bug 262209: 123571 | 123586