Attachment #123586 for bug #262209




			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.




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.

	 * @see org.eclipse.jdt.internal.compiler.lookup.MethodBinding#tiebreakMethod()
	 */
	public MethodBinding tiebreakMethod() {
		if (this.tiebreakMethod == null)
			this.tiebreakMethod = this.originalMethod.asRawMethod(this.environment);
			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);
		} 
		return this.tiebreakMethod;
	}
}




			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
	 */




		int oneParamsLength = oneParams.length;
		int twoParamsLength = twoParams.length;
		if (oneParamsLength == twoParamsLength) {
			next : for (int i = 0; i < oneParamsLength; i++) {
				TypeBinding oneParam = oneParams[i];
				TypeBinding twoParam = twoParams[i];
				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()) {




	        case Wildcard.UNBOUND :
	            return true;
	        case Wildcard.EXTENDS :
	            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 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()
	 */

Lines 940-945 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java (+315 lines)
940	false	940	false
941	);	941	);
942	}	942	}
		943	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=262209
		944	public void test014i() {
		945	this.runNegativeTest(
		946	new String[] {
		947	"X.java",
		948	"interface I<T> {}\n" +
		949	"interface J<T> extends I<T> {}\n" +
		950	"\n" +
		951	"class X {\n" +
		952	" void a(G x) {}\n" +
		953	" <T extends C, S extends F<T>> void a(S x) {}\n" +
		954	"\n" +
		955	" void b(G x) {}\n" +
		956	" void b(F x) {}\n" +
		957	"\n" +
		958	" void c(G x) {}\n" +
		959	" void c(F<?> x) {}\n" +
		960	"\n" +
		961	" void d(G x) {}\n" +
		962	" void d(F<C> x) {}\n" +
		963	"\n" +
		964	" void e(G x) {}\n" +
		965	" <T extends C> void e(F<T> x) {}\n" +
		966	"\n" +
		967	" void f(G x) {}\n" +
		968	" <S extends F> void f(S x) {}\n" +
		969	"\n" +
		970	" void g(G x) {}\n" +
		971	" <S extends F & J<S>> void g(S x) {}\n" +
		972	"\n" +
		973	" <T extends G> void a2(T x) {}\n" +
		974	" <T extends C, S extends F<T>> void a2(S x) {}\n" +
		975	"\n" +
		976	" <T extends G> void b2(T x) {}\n" +
		977	" void b2(F x) {}\n" +
		978	"\n" +
		979	" <T extends G> void c2(T x) {}\n" +
		980	" void c2(F<?> x) {}\n" +
		981	"\n" +
		982	" <T extends G> void d2(T x) {}\n" +
		983	" void d2(F<C> x) {}\n" +
		984	"\n" +
		985	" <T extends G> void e2(T x) {}\n" +
		986	" <T extends C> void e2(F<T> x) {}\n" +
		987	"\n" +
		988	" <T extends G> void f2(T x) {}\n" +
		989	" <S extends F & J> void f2(S x) {}\n" +
		990	"\n" +
		991	" <T extends G> void g2(T x) {}\n" +
		992	" <S extends F & J<S>> void g2(S x) {}\n" +
		993	"\n" +
		994	" void test() {\n" +
		995	" X x = new X();\n" +
		996	" H<C> h = null;\n" +
		997	" H hraw = null;\n" +
		998	"\n" +
		999	" x.a(h);\n" +
		1000	" x.a(hraw);\n" +
		1001	"\n" +
		1002	" x.b(h);\n" +
		1003	" x.b(hraw);\n" +
		1004	"\n" +
		1005	" x.c(h);\n" +
		1006	" x.c(hraw);\n" +
1007	"\n" +
1008	" x.d(h);\n" +
1009	" x.d(hraw);\n" +
1010	"\n" +
1011	" x.e(h);\n" +
1012	" x.e(hraw);\n" +
1013	"\n" +
1014	" x.f(h);\n" +
1015	" x.f(hraw);\n" +
1016	"\n" +
1017	" x.g(h);\n" +
1018	" x.g(hraw);\n" +
1019	"\n" +
1020	" x.a2(h);\n" +
1021	" x.a2(hraw);\n" +
1022	"\n" +
1023	" x.b2(h); \n" +
1024	" x.b2(hraw);\n" +
1025	"\n" +
1026	" x.c2(h);\n" +
1027	" x.c2(hraw);\n" +
1028	"\n" +
1029	" x.d2(h);\n" +
1030	" x.d2(hraw);\n" +
1031	"\n" +
1032	" x.e2(h);\n" +
1033	" x.e2(hraw);\n" +
1034	"\n" +
1035	" x.f2(h);\n" +
1036	" x.f2(hraw);\n" +
1037	"\n" +
1038	" x.g2(h); \n" +
1039	" x.g2(hraw);\n" +
1040	" }\n" +
1041	"}\n" +
1042	"\n" +
1043	"class A {}\n" +
1044	"class B extends A {}\n" +
1045	"class C extends B implements I {}\n" +
1046	"class F<T1> {} \n" +
1047	"class G<T2> extends F<T2> implements J<T2> {}\n" +
1048	"class H<T3> extends G<T3> {}\n"
1049	},
1050	"----------\n" +
1051	"1. WARNING in X.java (at line 5)\n" +
1052	" void a(G x) {}\n" +
1053	" ^\n" +
1054	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1055	"----------\n" +
1056	"2. WARNING in X.java (at line 8)\n" +
1057	" void b(G x) {}\n" +
1058	" ^\n" +
1059	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1060	"----------\n" +
1061	"3. WARNING in X.java (at line 9)\n" +
1062	" void b(F x) {}\n" +
1063	" ^\n" +
1064	"F is a raw type. References to generic type F<T1> should be parameterized\n" +
1065	"----------\n" +
1066	"4. WARNING in X.java (at line 11)\n" +
1067	" void c(G x) {}\n" +
1068	" ^\n" +
1069	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1070	"----------\n" +
1071	"5. WARNING in X.java (at line 14)\n" +
1072	" void d(G x) {}\n" +
1073	" ^\n" +
1074	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1075	"----------\n" +
1076	"6. WARNING in X.java (at line 17)\n" +
1077	" void e(G x) {}\n" +
1078	" ^\n" +
1079	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1080	"----------\n" +
1081	"7. WARNING in X.java (at line 20)\n" +
1082	" void f(G x) {}\n" +
1083	" ^\n" +
1084	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1085	"----------\n" +
1086	"8. WARNING in X.java (at line 21)\n" +
1087	" <S extends F> void f(S x) {}\n" +
1088	" ^\n" +
1089	"F is a raw type. References to generic type F<T1> should be parameterized\n" +
1090	"----------\n" +
1091	"9. WARNING in X.java (at line 23)\n" +
1092	" void g(G x) {}\n" +
1093	" ^\n" +
1094	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1095	"----------\n" +
1096	"10. WARNING in X.java (at line 24)\n" +
1097	" <S extends F & J<S>> void g(S x) {}\n" +
1098	" ^\n" +
1099	"F is a raw type. References to generic type F<T1> should be parameterized\n" +
1100	"----------\n" +
1101	"11. WARNING in X.java (at line 26)\n" +
1102	" <T extends G> void a2(T x) {}\n" +
1103	" ^\n" +
1104	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1105	"----------\n" +
1106	"12. WARNING in X.java (at line 29)\n" +
1107	" <T extends G> void b2(T x) {}\n" +
1108	" ^\n" +
1109	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1110	"----------\n" +
1111	"13. WARNING in X.java (at line 30)\n" +
1112	" void b2(F x) {}\n" +
1113	" ^\n" +
1114	"F is a raw type. References to generic type F<T1> should be parameterized\n" +
1115	"----------\n" +
1116	"14. WARNING in X.java (at line 32)\n" +
1117	" <T extends G> void c2(T x) {}\n" +
1118	" ^\n" +
1119	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1120	"----------\n" +
1121	"15. WARNING in X.java (at line 35)\n" +
1122	" <T extends G> void d2(T x) {}\n" +
1123	" ^\n" +
1124	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1125	"----------\n" +
1126	"16. WARNING in X.java (at line 38)\n" +
1127	" <T extends G> void e2(T x) {}\n" +
1128	" ^\n" +
1129	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1130	"----------\n" +
1131	"17. WARNING in X.java (at line 41)\n" +
1132	" <T extends G> void f2(T x) {}\n" +
1133	" ^\n" +
1134	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1135	"----------\n" +
1136	"18. WARNING in X.java (at line 42)\n" +
1137	" <S extends F & J> void f2(S x) {}\n" +
1138	" ^\n" +
1139	"F is a raw type. References to generic type F<T1> should be parameterized\n" +
1140	"----------\n" +
1141	"19. WARNING in X.java (at line 42)\n" +
1142	" <S extends F & J> void f2(S x) {}\n" +
1143	" ^\n" +
1144	"J is a raw type. References to generic type J<T> should be parameterized\n" +
1145	"----------\n" +
1146	"20. WARNING in X.java (at line 44)\n" +
1147	" <T extends G> void g2(T x) {}\n" +
1148	" ^\n" +
1149	"G is a raw type. References to generic type G<T2> should be parameterized\n" +
1150	"----------\n" +
1151	"21. WARNING in X.java (at line 45)\n" +
1152	" <S extends F & J<S>> void g2(S x) {}\n" +
1153	" ^\n" +
1154	"F is a raw type. References to generic type F<T1> should be parameterized\n" +
1155	"----------\n" +
1156	"22. WARNING in X.java (at line 50)\n" +
1157	" H hraw = null;\n" +
1158	" ^\n" +
1159	"H is a raw type. References to generic type H<T3> should be parameterized\n" +
1160	"----------\n" +
1161	"23. ERROR in X.java (at line 52)\n" +
1162	" x.a(h);\n" +
1163	" ^\n" +
1164	"The method a(G) is ambiguous for the type X\n" +
1165	"----------\n" +
1166	"24. ERROR in X.java (at line 53)\n" +
1167	" x.a(hraw);\n" +
1168	" ^\n" +
1169	"The method a(G) is ambiguous for the type X\n" +
1170	"----------\n" +
1171	"25. ERROR in X.java (at line 58)\n" +
1172	" x.c(h);\n" +
1173	" ^\n" +
1174	"The method c(G) is ambiguous for the type X\n" +
1175	"----------\n" +
1176	"26. ERROR in X.java (at line 59)\n" +
1177	" x.c(hraw);\n" +
1178	" ^\n" +
1179	"The method c(G) is ambiguous for the type X\n" +
1180	"----------\n" +
1181	"27. ERROR in X.java (at line 61)\n" +
1182	" x.d(h);\n" +
1183	" ^\n" +
1184	"The method d(G) is ambiguous for the type X\n" +
1185	"----------\n" +
1186	"28. ERROR in X.java (at line 62)\n" +
1187	" x.d(hraw);\n" +
1188	" ^\n" +
1189	"The method d(G) is ambiguous for the type X\n" +
1190	"----------\n" +
1191	"29. ERROR in X.java (at line 64)\n" +
1192	" x.e(h);\n" +
1193	" ^\n" +
1194	"The method e(G) is ambiguous for the type X\n" +
1195	"----------\n" +
1196	"30. ERROR in X.java (at line 65)\n" +
1197	" x.e(hraw);\n" +
1198	" ^\n" +
1199	"The method e(G) is ambiguous for the type X\n" +
1200	"----------\n" +
1201	"31. ERROR in X.java (at line 71)\n" +
1202	" x.g(hraw);\n" +
1203	" ^\n" +
1204	"The method g(G) is ambiguous for the type X\n" +
1205	"----------\n" +
1206	"32. ERROR in X.java (at line 73)\n" +
1207	" x.a2(h);\n" +
1208	" ^^\n" +
1209	"The method a2(H<C>) is ambiguous for the type X\n" +
1210	"----------\n" +
1211	"33. ERROR in X.java (at line 74)\n" +
1212	" x.a2(hraw);\n" +
1213	" ^^\n" +
1214	"The method a2(H) is ambiguous for the type X\n" +
1215	"----------\n" +
1216	"34. ERROR in X.java (at line 79)\n" +
1217	" x.c2(h);\n" +
1218	" ^^\n" +
1219	"The method c2(H<C>) is ambiguous for the type X\n" +
1220	"----------\n" +
1221	"35. ERROR in X.java (at line 80)\n" +
1222	" x.c2(hraw);\n" +
1223	" ^^\n" +
1224	"The method c2(H) is ambiguous for the type X\n" +
1225	"----------\n" +
1226	"36. ERROR in X.java (at line 82)\n" +
1227	" x.d2(h);\n" +
1228	" ^^\n" +
1229	"The method d2(H<C>) is ambiguous for the type X\n" +
1230	"----------\n" +
1231	"37. ERROR in X.java (at line 83)\n" +
1232	" x.d2(hraw);\n" +
1233	" ^^\n" +
1234	"The method d2(H) is ambiguous for the type X\n" +
1235	"----------\n" +
1236	"38. ERROR in X.java (at line 85)\n" +
1237	" x.e2(h);\n" +
1238	" ^^\n" +
1239	"The method e2(H<C>) is ambiguous for the type X\n" +
1240	"----------\n" +
1241	"39. ERROR in X.java (at line 86)\n" +
1242	" x.e2(hraw);\n" +
1243	" ^^\n" +
1244	"The method e2(H) is ambiguous for the type X\n" +
1245	"----------\n" +
1246	"40. ERROR in X.java (at line 92)\n" +
1247	" x.g2(hraw);\n" +
1248	" ^^\n" +
1249	"The method g2(H) is ambiguous for the type X\n" +
1250	"----------\n" +
1251	"41. WARNING in X.java (at line 98)\n" +
1252	" class C extends B implements I {}\n" +
1253	" ^\n" +
1254	"I is a raw type. References to generic type I<T> should be parameterized\n" +
1255	"----------\n"
1256	);
1257	}
943	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=79798	1258	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=79798
944	public void test015() {	1259	public void test015() {
945	this.runConformTest(	1260	this.runConformTest(

Return to bug 262209

Lines 293-299 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/TypeVariableBinding.java (-1 / +13 lines)
293	return this.superInterfaces.length;	293	return this.superInterfaces.length;
294	}	294	}
295	}	295	}
296		296
		297	boolean hasOnlyRawBounds() {
		298	if (this.superclass != null && !this.superclass.isRawType())
		299	return false;
		300
		301	if (this.superInterfaces != null)
		302	for (int i = 0, l = this.superInterfaces.length; i < l; i++)
		303	if (!this.superInterfaces[i].isRawType())
		304	return false;
		305
		306	return true;
		307	}
		308
297	/**	309	/**
298	* Returns true if the type variable is directly bound to a given type	310	* Returns true if the type variable is directly bound to a given type
299	*/	311	*/

Lines 2652-2678 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java (-19 / +22 lines)
2652	int oneParamsLength = oneParams.length;	2652	int oneParamsLength = oneParams.length;
2653	int twoParamsLength = twoParams.length;	2653	int twoParamsLength = twoParams.length;
2654	if (oneParamsLength == twoParamsLength) {	2654	if (oneParamsLength == twoParamsLength) {
2655	for (int i = 0; i < oneParamsLength; i++) {	2655	next : for (int i = 0; i < oneParamsLength; i++) {
2656	TypeBinding oneParam = oneParams[i];	2656	TypeBinding oneParam = oneParams[i];
2657	TypeBinding twoParam = twoParams[i];	2657	TypeBinding twoParam = twoParams[i];
2658	if (oneParam == twoParam) {	2658	if (oneParam == twoParam \|\| oneParam.isCompatibleWith(twoParam)) {
2659	if (twoParam.leafComponentType().isRawType()) {	2659	if (two.declaringClass.isRawType()) continue next;
2660	// must detect & reject this case	2660
2661	// when Y<U> extends X<U>	2661	TypeBinding originalOneParam = one.original().parameters[i].leafComponentType();
2662	// void foo(Y y) {}	2662	switch (originalOneParam.kind()) {
2663	// <T extends X<Object>> void foo(T t) {}	2663	case Binding.TYPE_PARAMETER :
2664	// foo(T) will show up as foo(Y#RAW) and not foo(X#RAW)	2664	if (!((TypeVariableBinding) originalOneParam).upperBound().isRawType()) break;
2665	// Y#RAW is not more specific than a rawified X<T>	2665	//$FALL-THROUGH$
2666	if (oneParam == one.original().parameters[i]	2666	case Binding.RAW_TYPE:
2667	&& twoParam.leafComponentType().erasure() != two.original().parameters[i].leafComponentType().erasure()) {	2667	// originalOneParam is RAW so it cannot be more specific than a wildcard or parameterized type
2668	return false;	2668	TypeBinding originalTwoParam = two.original().parameters[i].leafComponentType();
2669	}	2669	switch (originalTwoParam.kind()) {
2670	}	2670	case Binding.TYPE_PARAMETER :
2671	} else if (oneParam.isCompatibleWith(twoParam)) {	2671	if (((TypeVariableBinding) originalTwoParam).hasOnlyRawBounds())
2672	if (oneParam.leafComponentType().isRawType()) {	2672	continue next;
2673	// A#RAW is not more specific than a rawified A<T>	2673	return false;
2674	if (oneParam.needsUncheckedConversion(two.declaringClass.isRawType() ? twoParam : two.original().parameters[i]))	2674	case Binding.WILDCARD_TYPE :
2675	return false;	2675	case Binding.INTERSECTION_TYPE:
		2676	case Binding.PARAMETERIZED_TYPE :
		2677	return false;
		2678	}
2676	}	2679	}
2677	} else {	2680	} else {
2678	if (i == oneParamsLength - 1 && one.isVarargs() && two.isVarargs()) {	2681	if (i == oneParamsLength - 1 && one.isVarargs() && two.isVarargs()) {

Lines 11-17 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/ParameterizedGenericMethodBinding.java (-17 / +2 lines)
11	package org.eclipse.jdt.internal.compiler.lookup;	11	package org.eclipse.jdt.internal.compiler.lookup;
12		12
13	import org.eclipse.jdt.internal.compiler.ast.MessageSend;	13	import org.eclipse.jdt.internal.compiler.ast.MessageSend;
14	import org.eclipse.jdt.internal.compiler.ast.Wildcard;
15		14
16	/**	15	/**
17	* Binding denoting a generic method after type parameter substitutions got performed.	16	* Binding denoting a generic method after type parameter substitutions got performed.
Lines 503-524 Link Here
503	* @see org.eclipse.jdt.internal.compiler.lookup.MethodBinding#tiebreakMethod()	502	* @see org.eclipse.jdt.internal.compiler.lookup.MethodBinding#tiebreakMethod()
504	*/	503	*/
505	public MethodBinding tiebreakMethod() {	504	public MethodBinding tiebreakMethod() {
506	if (this.tiebreakMethod == null) {	505	if (this.tiebreakMethod == null)
507	TypeVariableBinding[] originalVariables = this.originalMethod.typeVariables;	506	this.tiebreakMethod = this.originalMethod.asRawMethod(this.environment);
508	int length = originalVariables.length;
509	TypeBinding[] newArguments = new TypeBinding[length];
510	for (int i = 0; i < length; i++) {
511	TypeVariableBinding originalVariable = originalVariables[i];
512	if (originalVariable.boundsCount() <= 1) {
513	newArguments[i] = this.environment.convertToRawType(originalVariable.upperBound(), false /do not force conversion of enclosing types/);
514	} else {
515	newArguments[i] = this.environment.convertToRawType(
516	// use an intersection type to retain full bound information
517	this.environment.createWildcard(null, 0, originalVariable.superclass(), originalVariable.superInterfaces(), Wildcard.EXTENDS), false /do not force conversion of enclosing types/);
518	}
519	}
520	this.tiebreakMethod = this.environment.createParameterizedGenericMethod(this.originalMethod, newArguments);
521	}
522	return this.tiebreakMethod;	507	return this.tiebreakMethod;
523	}	508	}
524	}	509	}

Lines 68-84 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/WildcardBinding.java (-6 / +6 lines)
68	case Wildcard.UNBOUND :	68	case Wildcard.UNBOUND :
69	return true;	69	return true;
70	case Wildcard.EXTENDS :	70	case Wildcard.EXTENDS :
71	if (argumentType.isCompatibleWith(this.bound)) return true;	71	if (!argumentType.isCompatibleWith(this.bound)) return false;
72	// check other bounds (lub scenario)	72	// check other bounds (lub scenario)
73	for (int i = 0, length = this.otherBounds == null ? 0 : this.otherBounds.length; i < length; i++) {	73	for (int i = 0, length = this.otherBounds == null ? 0 : this.otherBounds.length; i < length; i++) {
74	if (argumentType.isCompatibleWith(this.otherBounds[i])) return true;	74	if (!argumentType.isCompatibleWith(this.otherBounds[i])) return false;
75	}	75	}
76	return false;	76	return true;
77	default: // SUPER	77	default: // SUPER
78	// ? super Exception ok for: IOException, since it would be ok for (Exception)ioException	78	// ? super Exception ok for: IOException, since it would be ok for (Exception)ioException
79	return argumentType.isCompatibleWith(this.bound);	79	return argumentType.isCompatibleWith(this.bound);
80	}	80	}
81	}	81	}
82	/**	82	/**
83	* @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#canBeInstantiated()	83	* @see org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding#canBeInstantiated()
84	*/	84	*/