public void test032b() {

	this.runConformTest(

		new String[] {

			"X.java",

			"class A<T> { }" +			

			"interface I {\n" + 

			"  <T extends Exception & Cloneable> A<T> foo(Number n);\n" +

			"}\n" +

			"interface J extends I {\n" +

			"  A<XX> foo(Number n);\n" +

			"}\n" + 

			"public abstract class X implements J {\n" + 

			"}\n" + 

			"abstract class XX extends Exception implements Cloneable {}"

		},

		"");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073

// variant

public void test032c() {

	this.runConformTest(

		new String[] {

			"X.java",

			"class A<T> { }" +			

			"interface I {\n" + 

			"  <T extends Exception & Cloneable> A<T> foo(Number n);\n" +

			"}\n" +

			"interface J extends I {\n" +

			"  <S extends XX>  A<S> foo(Number n);\n" +

			"}\n" + 

			"public abstract class X implements J {\n" + 

			"}\n" + 

			"abstract class XX extends Exception implements Cloneable {}"

		},

		"");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073

// variant

public void test032d() {

	this.runConformTest(

		new String[] {

			"X.java",

			"class A<T> { }" +			

			"interface I {\n" + 

			"  A<XX> foo(Number n);\n" +

			"}\n" +

			"interface J extends I {\n" +

			"  <T extends Exception & Cloneable> A<T> foo(Number n);\n" +

			"}\n" + 

			"public abstract class X implements J {\n" + 

			"}\n" + 

			"abstract class XX extends Exception implements Cloneable {}"

		},

		"");

}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073

// variant

	if (length <= 1) {

		return true; // no need to continue since only 1 inherited method is left

	}

	// get rid of overriden methods coming from interfaces - if any

	MethodBinding methodsToCheck[] = new MethodBinding[length];	// must not nullify methods slots in place

	int count = length;

	for (int i = 0; i < length; i++) {

		methodsToCheck[i] = methods[i];

	}

	for (int i = 0; i < length; i++) {

		MethodBinding existingMethod;

		if ((existingMethod = methodsToCheck[i]) != null) {

			for (int j = 0; j < length; j++) {

				MethodBinding inheritedMethod;

				if (i != j && (inheritedMethod = methodsToCheck[j]) != null &&

						existingMethod.declaringClass.implementsInterface(inheritedMethod.declaringClass, true)) {

					MethodBinding substitute = computeSubstituteMethod(inheritedMethod, existingMethod);

					if (substitute != null && 

							doesSubstituteMethodOverride(existingMethod, substitute) &&

							(existingMethod.returnType.isCompatibleWith(substitute.returnType) ||

									isReturnTypeSubstituable(substitute, existingMethod))) {

						count--;

						methodsToCheck[j] = null;

					}

				}

			}

		}

	}

	if (count < length) {

		if (count == 1) { 

			return true; // no need to continue since only 1 inherited method is left

		}

		for (int i = 0, j = 0; j < count; i++) {

			if (methodsToCheck[i] != null) {

				methodsToCheck[j++] = methodsToCheck[i];

			}

		}

		methods = methodsToCheck;

		length = count;

	} // else keep methods unchanged for further checks

/**

 * Return true iff the return type of existingMethod is a valid replacement for

 * the one of substituteMethod in a method declaration, in the context specified 

 * thereafter. It is expected that substituteMethod is the result of the 

 * substitution of the type parameters of an inheritedMethod method according to 

 * the type parameters of existingMethod and the inheritance relationship 

 * between existingMethod's declaring type and inheritedMethod's declaring type,

 * where inheritedMethod is a method inherited by existingMethod's declaring 

 * type which is override compatible with existingMethod, except maybe for

 * their respective return types. If those conditions are not met, the result is

 * unspecified.

 * @param substituteMethod a proper substitute of a method inherited by existingMethod 

 * @param existingMethod the existing method under examination

 * @return true if the return type of existingMethod is a valid substitute for

 *         the one of substituteMethod

 */

boolean isReturnTypeSubstituable(MethodBinding substituteMethod, MethodBinding existingMethod) {

	class ReturnTypeSubstitution implements Substitution {

		TypeBinding replaced, replacer;

		ReturnTypeSubstitution(TypeBinding replaced, TypeBinding replacer) {

			this.replaced = replaced;

			this.replacer = replacer;

		}

		public LookupEnvironment environment() { 

			return environment; 

		}

		public boolean isRawSubstitution() { 

			return false; 

		}

		public TypeBinding substitute(TypeVariableBinding typeVariable) {

			return typeVariable == replaced ? replacer : typeVariable;

		}

	}

	if (substituteMethod.returnType instanceof TypeVariableBinding) {

		return ((TypeVariableBinding) substituteMethod.returnType).

			boundCheck(

				new ReturnTypeSubstitution(substituteMethod.returnType, existingMethod.returnType),

				existingMethod.returnType)  == TypeConstants.OK;

	} else if (substituteMethod.returnType instanceof ParameterizedTypeBinding) {

		if (! (existingMethod.returnType instanceof ParameterizedTypeBinding)) {

			return false;

		}

		ParameterizedTypeBinding substituteReturnType = (ParameterizedTypeBinding) substituteMethod.returnType,

			existingReturnType = (ParameterizedTypeBinding) existingMethod.returnType;

		if (substituteReturnType.type != existingReturnType.type) {

			return false;

		}

		for (int i = 0; i < substituteReturnType.arguments.length; i++) {

			TypeBinding substituteArgumentType, existingArgumentType;

			if (! (existingArgumentType = existingReturnType.arguments[i]).isCompatibleWith(

					substituteArgumentType = substituteReturnType.arguments[i])) {

				if (substituteArgumentType instanceof TypeVariableBinding) {

					if (((TypeVariableBinding) substituteArgumentType).

							boundCheck(

								new ReturnTypeSubstitution(substituteArgumentType, existingArgumentType),

								// we do not address the most general pattern of multiple type variables, nor the recursive case either

								existingArgumentType) != TypeConstants.OK) {

						return false;

					}

				} else {

					return false;

				}

			}

		}

		return true;

	}

	return false;

}