Attachment #65087 for bug #184293

View | Details | Raw Unified | Return to bug 184293
Collapse All | Expand All




				"}", // =================			
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 11)\n" + 
			"	abstract class GLinkElementView<M,CM> extends AbstractLinkView<M> {}\n" + 
			"	               ^^^^^^^^^^^^^^^^\n" + 
			"The return type is incompatible with ILinkViewElement.getViewer(), AbstractEditPart.getViewer(), AbstractLinkView<M>.getViewer()\n" + 
			"----------\n" + 
			"2. ERROR in X.java (at line 11)\n" + 
			"	public SheetViewer getViewer() { return null; }	\n" + 
			"	       ^^^^^^^^^^^\n" + 
			"The return type is incompatible with AbstractEditPart.getViewer()\n" + 




			new String[] {
				"A.java",
				"abstract class A implements I {}\n" +
				"interface I extends J { Object foo(); }\n" + // with javac only this type gets an error
				"interface J { String foo(); }\n",
				"X.java",
				"abstract class X2 extends A implements J {}\n"
			},
			"----------\n" + 
			"1. ERROR in A.java (at line 2)\n" + 
			"	abstract class A implements I {}\n" + 
			"	               ^\n" + 
			"The return type is incompatible with J.foo(), I.foo()\n" + 
			"----------\n" + 
			"2. ERROR in A.java (at line 2)\n" + 
			"	interface I extends J { Object foo(); }\n" + 
			"	                        ^^^^^^\n" + 
			"The return type is incompatible with J.foo()\n" + 
			"----------\n" + 
			"----------\n" + 
			"1. ERROR in X.java (at line 1)\n" + 
			"	abstract class X2 extends A implements J {}\n" + 
			"	               ^^\n" + 
			"The return type is incompatible with I.foo(), J.foo()\n" + 
			"----------\n"
		);
	}

		"----------\n"
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
public void test134() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"interface I {\n" + 
			"  <T extends Exception & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  A foo(Number n);\n" +  // warning: overrides <T>foo(java.lang.Number) in I; return type requires unchecked conversion
			"}\n" + 
			"abstract class A extends Exception implements Cloneable {}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 5)\n" + 
		"	A foo(Number n);\n" + 
		"	^\n" + 
		"Type safety: The return type A for foo(Number) from the type J needs unchecked conversion to conform to T from the type I\n" + 
		"----------\n"
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
public void test135() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"abstract class X implements J {}\n" + 
			"class X2 implements J {\n" + 
			"  public A foo(Number n) { return null; }\n" +
			"}\n" + 
			"abstract class Y extends X {}\n" + 
			"interface I {\n" + 
			"  <T extends Exception & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  A foo(Number n);\n" +  // warning: overrides <T>foo(java.lang.Number) in I; return type requires unchecked conversion
			"}\n" + 
			"abstract class A extends Exception implements Cloneable {}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 10)\n" + 
		"	A foo(Number n);\n" + 
		"	^\n" + 
		"Type safety: The return type A for foo(Number) from the type J needs unchecked conversion to conform to T from the type I\n" + 
		"----------\n"
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
public void test136() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public abstract class X extends E {}\n" + 
			"class X2 extends E {\n" + 
			"  @Override public A foo(Number n) { return null; }\n" +
			"}\n" + 
			"abstract class Y extends X {}\n" + 
			"abstract class D {\n" + 
			"  abstract <T extends Exception & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"abstract class E extends D {\n" + 
			"  @Override abstract A foo(Number n);\n" +  // warning: overrides <T>foo(java.lang.Number) in I; return type requires unchecked conversion
			"}\n" + 
			"abstract class A extends Exception implements Cloneable {}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 10)\n" + 
		"	@Override abstract A foo(Number n);\n" + 
		"	                   ^\n" + 
		"Type safety: The return type A for foo(Number) from the type E needs unchecked conversion to conform to T from the type D\n" + 
		"----------\n"
		// javac reports warnings against X AND Y about E.foo(), as well as reporting the warning on E.foo() twice
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
public void test137() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public abstract class X implements J {}\n" + 
			"interface I {\n" + 
			"  <T extends Y<T> & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  XX foo(Number n);\n" + 
			"}\n" + 
			"class Z { }\n" +
			"class Y <U> extends Z { }" +
			"abstract class XX extends Y<XX> implements Cloneable {}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 6)\n" + 
		"	XX foo(Number n);\n" + 
		"	^^\n" + 
		"Type safety: The return type XX for foo(Number) from the type J needs unchecked conversion to conform to T from the type I\n" + 
		"----------\n"
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
public void test138() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public abstract class X implements J {}\n" + 
			"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" + 
			"class A<T> { }" +			
			"abstract class XX extends Exception implements Cloneable {}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 6)\n" + 
		"	A<XX> foo(Number n);\n" + 
		"	^\n" + 
		"Type safety: The return type A<XX> for foo(Number) from the type J needs unchecked conversion to conform to A<T> from the type I\n" + 
		"----------\n"
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
public void test139() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public abstract class X implements J {\n" + 
			"  void foo() {}\n" + 
			"  public XX foo(Number n) { return null; }\n" + 
			"}\n" + 
			"interface I {\n" + 
			"  <T extends Exception & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  XX foo(Number n);\n" + 
			"}\n" + 
			"abstract class XX extends Exception implements Cloneable {}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 9)\n" + 
		"	XX foo(Number n);\n" + 
		"	^^\n" + 
		"Type safety: The return type XX for foo(Number) from the type J needs unchecked conversion to conform to T from the type I\n" + 
		"----------\n"
	);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
public void test140() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"public abstract class X implements J, K {}\n" + 
			"interface I {\n" + 
			"  <T extends Exception & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  XX foo(Number n);\n" + 
			"}\n" + 
			"interface K {\n" + 
			"  NullPointerException foo(Number n);\n" + 
			"}\n" + 
			"abstract class XX extends Exception implements Cloneable {}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 1)\n" + 
		"	public abstract class X implements J, K {}\n" + 
		"	                      ^\n" + 
		"The return type is incompatible with K.foo(Number), J.foo(Number)\n" + 
		"----------\n" + 
		"2. WARNING in X.java (at line 6)\n" + 
		"	XX foo(Number n);\n" + 
		"	^^\n" + 
		"Type safety: The return type XX for foo(Number) from the type J needs unchecked conversion to conform to T from the type I\n" + 
		"----------\n"
	);
}
}




		},
		"");
}
//tests 32-34 were moved to MethodVerityTest 134-140

	this.runConformTest(
		new String[] {
			"X.java",
			"interface I {\n" + 
			"  <T extends Exception & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  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 that shows that the use of a substitution is needed during the bounds
// check
public void test032a() {
	this.runConformTest(
		new String[] {
			"X.java",
			"class Z { }\n" +
			"class Y <U> extends Z { }" +
			"interface I {\n" + 
			"  <T extends Y<T> & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  XX foo(Number n);\n" + 
			"}\n" + 
			"public abstract class X implements J {\n" + 
			"}\n" + 
			"abstract class XX extends Y<XX> implements Cloneable {}"
		},
		"");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
// variant
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
public void test033() {
	this.runConformTest(
		new String[] {
			"X.java",
			"interface I {\n" + 
			"  <T extends Exception & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  XX foo(Number n);\n" + 
			"}\n" + 
			"public abstract class X implements J {\n" + 
			"  void foo() {\n" + 
			"  }\n" + 
			"  public XX foo(Number n) {\n" + 
			"    return null;\n" + 
			"  }\n" + 
			"}\n" + 
			"abstract class XX extends Exception implements Cloneable {}"
		},
		"");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
// variant that rightly complains
public void test034() {
	this.runNegativeTest(
		new String[] {
			"X.java",
			"interface I {\n" + 
			"  <T extends Exception & Cloneable> T foo(Number n);\n" + 
			"}\n" + 
			"interface J extends I {\n" + 
			"  XX foo(Number n);\n" + 
			"}\n" + 
			"interface K {\n" + 
			"  NullPointerException foo(Number n);\n" + 
			"}\n" + 
			"public abstract class X implements J, K {\n" + 
			"}\n" + 
			"abstract class XX extends Exception implements Cloneable {}"
		},
		"----------\n" + 
		"1. WARNING in X.java (at line 5)\n" + 
		"	XX foo(Number n);\n" + 
		"	^^\n" + 
		"Type safety: The return type XX for foo(Number) from the type J needs unchecked conversion to conform to T from the type I\n" + 
		"----------\n" + 
		"2. ERROR in X.java (at line 10)\n" + 
		"	public abstract class X implements J, K {\n" + 
		"	                      ^\n" + 
		"The return type is incompatible with K.foo(Number), J.foo(Number)\n" + 
		"----------\n");
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065
// variant - the inheriting class implements foo
public void test035() {




boolean checkInheritedReturnTypes(MethodBinding[] methods, int length) {
	if (methods[0].declaringClass.isClass())
		return super.checkInheritedReturnTypes(methods, length);
	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

	// its possible in 1.5 that A is compatible with B & C, but B is not compatible with C
	for (int i = 0, l = length - 1; i < l;) {
		MethodBinding method = methods[i++];
		nextMethod : for (int j = i; j <= l; j++) {
			if (!areReturnTypesCompatible(method, methods[j])) {
				if (this.type.isInterface())
					for (int m = length; --m >= 0;)
						if (methods[m].declaringClass.id == TypeIds.T_JavaLangObject)
							continue nextMethod; // do not complain since the super interface already got blamed
				problemReporter().inheritedMethodsHaveIncompatibleReturnTypes(this.type, methods, length);
				return false;
			}

	// one has type variables and substituteTwo did not pass bounds check in computeSubstituteMethod()
	return one.typeVariables != Binding.NO_TYPE_VARIABLES && !(substituteTwo instanceof ParameterizedGenericMethodBinding);
}
// caveat: returns false if a method is implemented that needs a bridge method
//         method be generated
boolean isInterfaceMethodImplemented(MethodBinding inheritedMethod, MethodBinding existingMethod, ReferenceBinding superType) {
	if (inheritedMethod.original() != inheritedMethod && existingMethod.declaringClass.isInterface())
		return false; // must hold onto ParameterizedMethod to see if a bridge method is necessary

	inheritedMethod = computeSubstituteMethod(inheritedMethod, existingMethod);
	return inheritedMethod != null
		&& inheritedMethod.returnType == existingMethod.returnType // keep around to produce bridge methods
		&& super.isInterfaceMethodImplemented(inheritedMethod, existingMethod, superType);
}
/**
 * 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.actualType() != existingReturnType.actualType())
			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;
}
SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) {
	ReferenceBinding[] interfacesToVisit = null;
	int nextPosition = 0;




		return; // do not repoort against subsequent inherited methods
	}
	CompilerOptions options = type.scope.compilerOptions();
	// need to find the overridden methods to avoid blaming this type for issues which are already reported against a supertype
	// but cannot ignore an overridden inherited method completely when it comes to checking for bridge methods
	int[] overriddenInheritedMethods = findOverriddenInheritedMethods(methods, length);
	nextMethod : for (int i = length; --i >= 0;) {
		MethodBinding inheritedMethod = methods[i];
		if (overriddenInheritedMethods == null || overriddenInheritedMethods[i] == 0) {
			if (currentMethod.isStatic() != inheritedMethod.isStatic()) {  // Cannot override a static method or hide an instance method
				problemReporter(currentMethod).staticAndInstanceConflict(currentMethod, inheritedMethod);
				continue nextMethod;
			}
	
			// want to tag currentMethod even if return types are not equal
			if (inheritedMethod.isAbstract()) {
				if (inheritedMethod.declaringClass.isInterface()) {
					currentMethod.modifiers |= ExtraCompilerModifiers.AccImplementing;
				} else {
					currentMethod.modifiers |= ExtraCompilerModifiers.AccImplementing | ExtraCompilerModifiers.AccOverriding;
				}
//			with the above change an abstract method is tagged as implementing the inherited abstract method
//			if (!currentMethod.isAbstract() && inheritedMethod.isAbstract()) {
//				if ((currentMethod.modifiers & CompilerModifiers.AccOverriding) == 0)
//					currentMethod.modifiers |= CompilerModifiers.AccImplementing;
			} else {
				currentMethod.modifiers |= ExtraCompilerModifiers.AccOverriding;
			}
	
			if (!areReturnTypesCompatible(currentMethod, inheritedMethod))
				if (reportIncompatibleReturnTypeError(currentMethod, inheritedMethod))
					continue nextMethod;
	
			if (currentMethod.thrownExceptions != Binding.NO_EXCEPTIONS)
				checkExceptions(currentMethod, inheritedMethod);
			if (inheritedMethod.isFinal())
				problemReporter(currentMethod).finalMethodCannotBeOverridden(currentMethod, inheritedMethod);
			if (!isAsVisible(currentMethod, inheritedMethod))
				problemReporter(currentMethod).visibilityConflict(currentMethod, inheritedMethod);
			if (options.reportDeprecationWhenOverridingDeprecatedMethod && inheritedMethod.isViewedAsDeprecated()) {
				if (!currentMethod.isViewedAsDeprecated() || options.reportDeprecationInsideDeprecatedCode) {
					// check against the other inherited methods to see if they hide this inheritedMethod
					ReferenceBinding declaringClass = inheritedMethod.declaringClass;
					if (declaringClass.isInterface())
						for (int j = length; --j >= 0;)
							if (i != j && methods[j].declaringClass.implementsInterface(declaringClass, false))
								continue nextMethod;
	
					problemReporter(currentMethod).overridesDeprecatedMethod(currentMethod, inheritedMethod);
				}
				if (declaringClass.isInterface())
					for (int j = length; --j >= 0;)
						if (i != j && methods[j].declaringClass.implementsInterface(declaringClass, false))
							continue nextMethod;

				problemReporter(currentMethod).overridesDeprecatedMethod(currentMethod, inheritedMethod);
			}
		}
		checkForBridgeMethod(currentMethod, inheritedMethod, allInheritedMethods);

	// no op before 1.5
}
void checkInheritedMethods(MethodBinding[] methods, int length) {
	int[] overriddenInheritedMethods = findOverriddenInheritedMethods(methods, length);
	if (overriddenInheritedMethods != null) {
		// detected some overridden methods that can be ignored when checking return types
		int index = 0;
		MethodBinding[] closestMethods = new MethodBinding[length];
		for (int i = 0; i < length; i++)
			if (overriddenInheritedMethods[i] == 0)
				closestMethods[index++] = methods[i];
		methods = closestMethods;
		length = index;
	}

	if (!checkInheritedReturnTypes(methods, length))
		return;


public boolean doesMethodOverride(MethodBinding method, MethodBinding inheritedMethod) {
	return areParametersEqual(method, inheritedMethod);
}
SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) {
	return null; // noop in 1.4
}
int[] findOverriddenInheritedMethods(MethodBinding[] methods, int length) {
	int[] toSkip = null;
	if (length > 1) {
		nextMethod : for (int i = 0; i < length; i++) {
			if (toSkip != null && toSkip[i] == -1) continue nextMethod;
			ReferenceBinding declaringClass = methods[i].declaringClass;
			if (declaringClass.isInterface()) {
				for (int j = 0; j < length; j++) {
					if (i == j) continue;
					ReferenceBinding declaringClass2 = methods[j].declaringClass;
					if (declaringClass2.isInterface() && declaringClass2.implementsInterface(declaringClass, true)) {
						if (toSkip == null)
							toSkip = new int[length];
						toSkip[i] = -1;
						continue nextMethod;
					}
				}
			} else { 
				for (int j = 0; j < length; j++) {
					if (i == j) continue;
					ReferenceBinding declaringClass2 = methods[j].declaringClass;
					if (!declaringClass2.isInterface() && declaringClass.isSuperclassOf(declaringClass2)) {
						if (toSkip == null)
							toSkip = new int[length];
						toSkip[i] = -1;
						continue nextMethod;
					}
				}
			}
		}
	}
	return toSkip;
}
boolean isAsVisible(MethodBinding newMethod, MethodBinding inheritedMethod) {
	if (inheritedMethod.modifiers == newMethod.modifiers) return true;


		reporter.referenceContext = currentMethod.sourceMethod();
	return reporter;
}
SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) {
	return null; // noop in 1.4
}
/**
 * Return true and report an incompatibleReturnType error if currentMethod's
 * return type is strictly incompatible with inheritedMethod's, else return 

Return to bug 184293

Lines 31605-31616 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java (-6 / +1 lines)
31605	"}", // =================	31605	"}", // =================
31606	},	31606	},
31607	"----------\n" +	31607	"----------\n" +
31608	"1. ERROR in X.java (at line 7)\n" +	31608	"1. ERROR in X.java (at line 11)\n" +
31609	" abstract class GLinkElementView<M,CM> extends AbstractLinkView<M> {}\n" +
31610	" ^^^^^^^^^^^^^^^^\n" +
31611	"The return type is incompatible with ILinkViewElement.getViewer(), AbstractEditPart.getViewer(), AbstractLinkView<M>.getViewer()\n" +
31612	"----------\n" +
31613	"2. ERROR in X.java (at line 11)\n" +
31614	" public SheetViewer getViewer() { return null; } \n" +	31609	" public SheetViewer getViewer() { return null; } \n" +
31615	" ^^^^^^^^^^^\n" +	31610	" ^^^^^^^^^^^\n" +
31616	"The return type is incompatible with AbstractEditPart.getViewer()\n" +	31611	"The return type is incompatible with AbstractEditPart.getViewer()\n" +

Lines 1456-1610 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java (-149 / +2 lines)
1456	},	1456	},
1457	"");	1457	"");
1458	}	1458	}
1459	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073	1459	//tests 32-34 were moved to MethodVerityTest 134-140
1460	public void test032() {	1460
1461	this.runConformTest(
1462	new String[] {
1463	"X.java",
1464	"interface I {\n" +
1465	" <T extends Exception & Cloneable> T foo(Number n);\n" +
1466	"}\n" +
1467	"interface J extends I {\n" +
1468	" XX foo(Number n);\n" +
1469	"}\n" +
1470	"public abstract class X implements J {\n" +
1471	"}\n" +
1472	"abstract class XX extends Exception implements Cloneable {}"
1473	},
1474	"");
1475	}
1476	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
1477	// variant that shows that the use of a substitution is needed during the bounds
1478	// check
1479	public void test032a() {
1480	this.runConformTest(
1481	new String[] {
1482	"X.java",
1483	"class Z { }\n" +
1484	"class Y <U> extends Z { }" +
1485	"interface I {\n" +
1486	" <T extends Y<T> & Cloneable> T foo(Number n);\n" +
1487	"}\n" +
1488	"interface J extends I {\n" +
1489	" XX foo(Number n);\n" +
1490	"}\n" +
1491	"public abstract class X implements J {\n" +
1492	"}\n" +
1493	"abstract class XX extends Y<XX> implements Cloneable {}"
1494	},
1495	"");
1496	}
1497	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
1498	// variant
1499	public void test032b() {
1500	this.runConformTest(
1501	new String[] {
1502	"X.java",
1503	"class A<T> { }" +
1504	"interface I {\n" +
1505	" <T extends Exception & Cloneable> A<T> foo(Number n);\n" +
1506	"}\n" +
1507	"interface J extends I {\n" +
1508	" A<XX> foo(Number n);\n" +
1509	"}\n" +
1510	"public abstract class X implements J {\n" +
1511	"}\n" +
1512	"abstract class XX extends Exception implements Cloneable {}"
1513	},
1514	"");
1515	}
1516	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
1517	// variant
1518	public void test032c() {
1519	this.runConformTest(
1520	new String[] {
1521	"X.java",
1522	"class A<T> { }" +
1523	"interface I {\n" +
1524	" <T extends Exception & Cloneable> A<T> foo(Number n);\n" +
1525	"}\n" +
1526	"interface J extends I {\n" +
1527	" <S extends XX> A<S> foo(Number n);\n" +
1528	"}\n" +
1529	"public abstract class X implements J {\n" +
1530	"}\n" +
1531	"abstract class XX extends Exception implements Cloneable {}"
1532	},
1533	"");
1534	}
1535	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
1536	// variant
1537	public void test032d() {
1538	this.runConformTest(
1539	new String[] {
1540	"X.java",
1541	"class A<T> { }" +
1542	"interface I {\n" +
1543	" A<XX> foo(Number n);\n" +
1544	"}\n" +
1545	"interface J extends I {\n" +
1546	" <T extends Exception & Cloneable> A<T> foo(Number n);\n" +
1547	"}\n" +
1548	"public abstract class X implements J {\n" +
1549	"}\n" +
1550	"abstract class XX extends Exception implements Cloneable {}"
1551	},
1552	"");
1553	}
1554	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
1555	// variant
1556	public void test033() {
1557	this.runConformTest(
1558	new String[] {
1559	"X.java",
1560	"interface I {\n" +
1561	" <T extends Exception & Cloneable> T foo(Number n);\n" +
1562	"}\n" +
1563	"interface J extends I {\n" +
1564	" XX foo(Number n);\n" +
1565	"}\n" +
1566	"public abstract class X implements J {\n" +
1567	" void foo() {\n" +
1568	" }\n" +
1569	" public XX foo(Number n) {\n" +
1570	" return null;\n" +
1571	" }\n" +
1572	"}\n" +
1573	"abstract class XX extends Exception implements Cloneable {}"
1574	},
1575	"");
1576	}
1577	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162073
1578	// variant that rightly complains
1579	public void test034() {
1580	this.runNegativeTest(
1581	new String[] {
1582	"X.java",
1583	"interface I {\n" +
1584	" <T extends Exception & Cloneable> T foo(Number n);\n" +
1585	"}\n" +
1586	"interface J extends I {\n" +
1587	" XX foo(Number n);\n" +
1588	"}\n" +
1589	"interface K {\n" +
1590	" NullPointerException foo(Number n);\n" +
1591	"}\n" +
1592	"public abstract class X implements J, K {\n" +
1593	"}\n" +
1594	"abstract class XX extends Exception implements Cloneable {}"
1595	},
1596	"----------\n" +
1597	"1. WARNING in X.java (at line 5)\n" +
1598	" XX foo(Number n);\n" +
1599	" ^^\n" +
1600	"Type safety: The return type XX for foo(Number) from the type J needs unchecked conversion to conform to T from the type I\n" +
1601	"----------\n" +
1602	"2. ERROR in X.java (at line 10)\n" +
1603	" public abstract class X implements J, K {\n" +
1604	" ^\n" +
1605	"The return type is incompatible with K.foo(Number), J.foo(Number)\n" +
1606	"----------\n");
1607	}
1608	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065	1461	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065
1609	// variant - the inheriting class implements foo	1462	// variant - the inheriting class implements foo
1610	public void test035() {	1463	public void test035() {

Lines 344-399 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java (-112 / +4 lines)
344	boolean checkInheritedReturnTypes(MethodBinding[] methods, int length) {	344	boolean checkInheritedReturnTypes(MethodBinding[] methods, int length) {
345	if (methods[0].declaringClass.isClass())	345	if (methods[0].declaringClass.isClass())
346	return super.checkInheritedReturnTypes(methods, length);	346	return super.checkInheritedReturnTypes(methods, length);
347	if (length <= 1) {
348	return true; // no need to continue since only 1 inherited method is left
349	}
350	// get rid of overriden methods coming from interfaces - if any
351	MethodBinding methodsToCheck[] = new MethodBinding[length]; // must not nullify methods slots in place
352	int count = length;
353	for (int i = 0; i < length; i++) {
354	methodsToCheck[i] = methods[i];
355	}
356	for (int i = 0; i < length; i++) {
357	MethodBinding existingMethod;
358	if ((existingMethod = methodsToCheck[i]) != null) {
359	for (int j = 0; j < length; j++) {
360	MethodBinding inheritedMethod;
361	if (i != j && (inheritedMethod = methodsToCheck[j]) != null &&
362	existingMethod.declaringClass.implementsInterface(inheritedMethod.declaringClass, true)) {
363	MethodBinding substitute = computeSubstituteMethod(inheritedMethod, existingMethod);
364	if (substitute != null &&
365	doesSubstituteMethodOverride(existingMethod, substitute) &&
366	(existingMethod.returnType.isCompatibleWith(substitute.returnType) \|\|
367	isReturnTypeSubstituable(substitute, existingMethod))) {
368	count--;
369	methodsToCheck[j] = null;
370	}
371	}
372	}
373	}
374	}
375	if (count < length) {
376	if (count == 1) {
377	return true; // no need to continue since only 1 inherited method is left
378	}
379	for (int i = 0, j = 0; j < count; i++) {
380	if (methodsToCheck[i] != null) {
381	methodsToCheck[j++] = methodsToCheck[i];
382	}
383	}
384	methods = methodsToCheck;
385	length = count;
386	} // else keep methods unchanged for further checks
387		347
388	// its possible in 1.5 that A is compatible with B & C, but B is not compatible with C	348	// its possible in 1.5 that A is compatible with B & C, but B is not compatible with C
389	for (int i = 0, l = length - 1; i < l;) {	349	for (int i = 0, l = length - 1; i < l;) {
390	MethodBinding method = methods[i++];	350	MethodBinding method = methods[i++];
391	for (int j = i; j <= l; j++) {	351	nextMethod : for (int j = i; j <= l; j++) {
392	if (!areReturnTypesCompatible(method, methods[j])) {	352	if (!areReturnTypesCompatible(method, methods[j])) {
393	if (this.type.isInterface())	353	if (this.type.isInterface())
394	for (int m = length; --m >= 0;)	354	for (int m = length; --m >= 0;)
395	if (methods[m].declaringClass.id == TypeIds.T_JavaLangObject)	355	if (methods[m].declaringClass.id == TypeIds.T_JavaLangObject)
396	return false; // do not complain since the super interface already got blamed	356	continue nextMethod; // do not complain since the super interface already got blamed
397	problemReporter().inheritedMethodsHaveIncompatibleReturnTypes(this.type, methods, length);	357	problemReporter().inheritedMethodsHaveIncompatibleReturnTypes(this.type, methods, length);
398	return false;	358	return false;
399	}	359	}
Lines 621-704 Link Here
621	// one has type variables and substituteTwo did not pass bounds check in computeSubstituteMethod()	581	// one has type variables and substituteTwo did not pass bounds check in computeSubstituteMethod()
622	return one.typeVariables != Binding.NO_TYPE_VARIABLES && !(substituteTwo instanceof ParameterizedGenericMethodBinding);	582	return one.typeVariables != Binding.NO_TYPE_VARIABLES && !(substituteTwo instanceof ParameterizedGenericMethodBinding);
623	}	583	}
624	// caveat: returns false if a method is implemented but needs that a bridge	584	// caveat: returns false if a method is implemented that needs a bridge method
625	// method be generated
626	boolean isInterfaceMethodImplemented(MethodBinding inheritedMethod, MethodBinding existingMethod, ReferenceBinding superType) {	585	boolean isInterfaceMethodImplemented(MethodBinding inheritedMethod, MethodBinding existingMethod, ReferenceBinding superType) {
627	if (inheritedMethod.original() != inheritedMethod && existingMethod.declaringClass.isInterface())	586	if (inheritedMethod.original() != inheritedMethod && existingMethod.declaringClass.isInterface())
628	return false; // must hold onto ParameterizedMethod to see if a bridge method is necessary	587	return false; // must hold onto ParameterizedMethod to see if a bridge method is necessary
629		588
630	inheritedMethod = computeSubstituteMethod(inheritedMethod, existingMethod);	589	inheritedMethod = computeSubstituteMethod(inheritedMethod, existingMethod);
631	return inheritedMethod != null	590	return inheritedMethod != null
632	&& inheritedMethod.returnType == existingMethod.returnType	591	&& inheritedMethod.returnType == existingMethod.returnType // keep around to produce bridge methods
633	&& super.isInterfaceMethodImplemented(inheritedMethod, existingMethod, superType);	592	&& super.isInterfaceMethodImplemented(inheritedMethod, existingMethod, superType);
634	}	593	}
635	/**
636	* Return true iff the return type of existingMethod is a valid replacement for
637	* the one of substituteMethod in a method declaration, in the context specified
638	* thereafter. It is expected that substituteMethod is the result of the
639	* substitution of the type parameters of an inheritedMethod method according to
640	* the type parameters of existingMethod and the inheritance relationship
641	* between existingMethod's declaring type and inheritedMethod's declaring type,
642	* where inheritedMethod is a method inherited by existingMethod's declaring
643	* type which is override compatible with existingMethod, except maybe for
644	* their respective return types. If those conditions are not met, the result is
645	* unspecified.
646	* @param substituteMethod a proper substitute of a method inherited by existingMethod
647	* @param existingMethod the existing method under examination
648	* @return true if the return type of existingMethod is a valid substitute for
649	* the one of substituteMethod
650	*/
651	boolean isReturnTypeSubstituable(MethodBinding substituteMethod, MethodBinding existingMethod) {
652	class ReturnTypeSubstitution implements Substitution {
653	TypeBinding replaced, replacer;
654	ReturnTypeSubstitution(TypeBinding replaced, TypeBinding replacer) {
655	this.replaced = replaced;
656	this.replacer = replacer;
657	}
658	public LookupEnvironment environment() {
659	return environment;
660	}
661	public boolean isRawSubstitution() {
662	return false;
663	}
664	public TypeBinding substitute(TypeVariableBinding typeVariable) {
665	return typeVariable == replaced ? replacer : typeVariable;
666	}
667	}
668	if (substituteMethod.returnType instanceof TypeVariableBinding) {
669	return ((TypeVariableBinding) substituteMethod.returnType).
670	boundCheck(
671	new ReturnTypeSubstitution(substituteMethod.returnType, existingMethod.returnType),
672	existingMethod.returnType) == TypeConstants.OK;
673	} else if (substituteMethod.returnType instanceof ParameterizedTypeBinding) {
674	if (! (existingMethod.returnType instanceof ParameterizedTypeBinding)) {
675	return false;
676	}
677	ParameterizedTypeBinding substituteReturnType = (ParameterizedTypeBinding) substituteMethod.returnType,
678	existingReturnType = (ParameterizedTypeBinding) existingMethod.returnType;
679	if (substituteReturnType.actualType() != existingReturnType.actualType())
680	return false;
681	for (int i = 0; i < substituteReturnType.arguments.length; i++) {
682	TypeBinding substituteArgumentType, existingArgumentType;
683	if (! (existingArgumentType = existingReturnType.arguments[i]).isCompatibleWith(
684	substituteArgumentType = substituteReturnType.arguments[i])) {
685	if (substituteArgumentType instanceof TypeVariableBinding) {
686	if (((TypeVariableBinding) substituteArgumentType).
687	boundCheck(
688	new ReturnTypeSubstitution(substituteArgumentType, existingArgumentType),
689	// we do not address the most general pattern of multiple type variables, nor the recursive case either
690	existingArgumentType) != TypeConstants.OK) {
691	return false;
692	}
693	} else {
694	return false;
695	}
696	}
697	}
698	return true;
699	}
700	return false;
701	}
702	SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) {	594	SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) {
703	ReferenceBinding[] interfacesToVisit = null;	595	ReferenceBinding[] interfacesToVisit = null;
704	int nextPosition = 0;	596	int nextPosition = 0;

Lines 141-188 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java (-41 / +91 lines)
141	return; // do not repoort against subsequent inherited methods	141	return; // do not repoort against subsequent inherited methods
142	}	142	}
143	CompilerOptions options = type.scope.compilerOptions();	143	CompilerOptions options = type.scope.compilerOptions();
		144	// need to find the overridden methods to avoid blaming this type for issues which are already reported against a supertype
		145	// but cannot ignore an overridden inherited method completely when it comes to checking for bridge methods
		146	int[] overriddenInheritedMethods = findOverriddenInheritedMethods(methods, length);
144	nextMethod : for (int i = length; --i >= 0;) {	147	nextMethod : for (int i = length; --i >= 0;) {
145	MethodBinding inheritedMethod = methods[i];	148	MethodBinding inheritedMethod = methods[i];
146	if (currentMethod.isStatic() != inheritedMethod.isStatic()) { // Cannot override a static method or hide an instance method	149	if (overriddenInheritedMethods == null \|\| overriddenInheritedMethods[i] == 0) {
147	problemReporter(currentMethod).staticAndInstanceConflict(currentMethod, inheritedMethod);	150	if (currentMethod.isStatic() != inheritedMethod.isStatic()) { // Cannot override a static method or hide an instance method
148	continue nextMethod;	151	problemReporter(currentMethod).staticAndInstanceConflict(currentMethod, inheritedMethod);
149	}	152	continue nextMethod;
150		153	}
151	// want to tag currentMethod even if return types are not equal	154
152	if (inheritedMethod.isAbstract()) {	155	// want to tag currentMethod even if return types are not equal
153	if (inheritedMethod.declaringClass.isInterface()) {	156	if (inheritedMethod.isAbstract()) {
154	currentMethod.modifiers \|= ExtraCompilerModifiers.AccImplementing;	157	if (inheritedMethod.declaringClass.isInterface()) {
		158	currentMethod.modifiers \|= ExtraCompilerModifiers.AccImplementing;
		159	} else {
		160	currentMethod.modifiers \|= ExtraCompilerModifiers.AccImplementing \| ExtraCompilerModifiers.AccOverriding;
		161	}
		162	// with the above change an abstract method is tagged as implementing the inherited abstract method
		163	// if (!currentMethod.isAbstract() && inheritedMethod.isAbstract()) {
		164	// if ((currentMethod.modifiers & CompilerModifiers.AccOverriding) == 0)
		165	// currentMethod.modifiers \|= CompilerModifiers.AccImplementing;
155	} else {	166	} else {
156	currentMethod.modifiers \|= ExtraCompilerModifiers.AccImplementing \| ExtraCompilerModifiers.AccOverriding;	167	currentMethod.modifiers \|= ExtraCompilerModifiers.AccOverriding;
157	}	168	}
158	// with the above change an abstract method is tagged as implementing the inherited abstract method	169
159	// if (!currentMethod.isAbstract() && inheritedMethod.isAbstract()) {	170	if (!areReturnTypesCompatible(currentMethod, inheritedMethod))
160	// if ((currentMethod.modifiers & CompilerModifiers.AccOverriding) == 0)	171	if (reportIncompatibleReturnTypeError(currentMethod, inheritedMethod))
161	// currentMethod.modifiers \|= CompilerModifiers.AccImplementing;	172	continue nextMethod;
162	} else {	173
163	currentMethod.modifiers \|= ExtraCompilerModifiers.AccOverriding;	174	if (currentMethod.thrownExceptions != Binding.NO_EXCEPTIONS)
164	}	175	checkExceptions(currentMethod, inheritedMethod);
165		176	if (inheritedMethod.isFinal())
166	if (!areReturnTypesCompatible(currentMethod, inheritedMethod))	177	problemReporter(currentMethod).finalMethodCannotBeOverridden(currentMethod, inheritedMethod);
167	if (reportIncompatibleReturnTypeError(currentMethod, inheritedMethod))	178	if (!isAsVisible(currentMethod, inheritedMethod))
168	continue nextMethod;	179	problemReporter(currentMethod).visibilityConflict(currentMethod, inheritedMethod);
169		180	if (options.reportDeprecationWhenOverridingDeprecatedMethod && inheritedMethod.isViewedAsDeprecated()) {
170	if (currentMethod.thrownExceptions != Binding.NO_EXCEPTIONS)	181	if (!currentMethod.isViewedAsDeprecated() \|\| options.reportDeprecationInsideDeprecatedCode) {
171	checkExceptions(currentMethod, inheritedMethod);	182	// check against the other inherited methods to see if they hide this inheritedMethod
172	if (inheritedMethod.isFinal())	183	ReferenceBinding declaringClass = inheritedMethod.declaringClass;
173	problemReporter(currentMethod).finalMethodCannotBeOverridden(currentMethod, inheritedMethod);	184	if (declaringClass.isInterface())
174	if (!isAsVisible(currentMethod, inheritedMethod))	185	for (int j = length; --j >= 0;)
175	problemReporter(currentMethod).visibilityConflict(currentMethod, inheritedMethod);	186	if (i != j && methods[j].declaringClass.implementsInterface(declaringClass, false))
176	if (options.reportDeprecationWhenOverridingDeprecatedMethod && inheritedMethod.isViewedAsDeprecated()) {	187	continue nextMethod;
177	if (!currentMethod.isViewedAsDeprecated() \|\| options.reportDeprecationInsideDeprecatedCode) {	188
178	// check against the other inherited methods to see if they hide this inheritedMethod	189	problemReporter(currentMethod).overridesDeprecatedMethod(currentMethod, inheritedMethod);
179	ReferenceBinding declaringClass = inheritedMethod.declaringClass;	190	}
180	if (declaringClass.isInterface())
181	for (int j = length; --j >= 0;)
182	if (i != j && methods[j].declaringClass.implementsInterface(declaringClass, false))
183	continue nextMethod;
184
185	problemReporter(currentMethod).overridesDeprecatedMethod(currentMethod, inheritedMethod);
186	}	191	}
187	}	192	}
188	checkForBridgeMethod(currentMethod, inheritedMethod, allInheritedMethods);	193	checkForBridgeMethod(currentMethod, inheritedMethod, allInheritedMethods);
Lines 231-236 Link Here
231	// no op before 1.5	236	// no op before 1.5
232	}	237	}
233	void checkInheritedMethods(MethodBinding[] methods, int length) {	238	void checkInheritedMethods(MethodBinding[] methods, int length) {
		239	int[] overriddenInheritedMethods = findOverriddenInheritedMethods(methods, length);
		240	if (overriddenInheritedMethods != null) {
		241	// detected some overridden methods that can be ignored when checking return types
		242	int index = 0;
		243	MethodBinding[] closestMethods = new MethodBinding[length];
		244	for (int i = 0; i < length; i++)
		245	if (overriddenInheritedMethods[i] == 0)
		246	closestMethods[index++] = methods[i];
		247	methods = closestMethods;
		248	length = index;
		249	}
		250
234	if (!checkInheritedReturnTypes(methods, length))	251	if (!checkInheritedReturnTypes(methods, length))
235	return;	252	return;
236		253
Lines 573-578 Link Here
573	public boolean doesMethodOverride(MethodBinding method, MethodBinding inheritedMethod) {	590	public boolean doesMethodOverride(MethodBinding method, MethodBinding inheritedMethod) {
574	return areParametersEqual(method, inheritedMethod);	591	return areParametersEqual(method, inheritedMethod);
575	}	592	}
		593	SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) {
		594	return null; // noop in 1.4
		595	}
		596	int[] findOverriddenInheritedMethods(MethodBinding[] methods, int length) {
		597	int[] toSkip = null;
		598	if (length > 1) {
		599	nextMethod : for (int i = 0; i < length; i++) {
		600	if (toSkip != null && toSkip[i] == -1) continue nextMethod;
		601	ReferenceBinding declaringClass = methods[i].declaringClass;
		602	if (declaringClass.isInterface()) {
		603	for (int j = 0; j < length; j++) {
		604	if (i == j) continue;
		605	ReferenceBinding declaringClass2 = methods[j].declaringClass;
		606	if (declaringClass2.isInterface() && declaringClass2.implementsInterface(declaringClass, true)) {
		607	if (toSkip == null)
		608	toSkip = new int[length];
		609	toSkip[i] = -1;
		610	continue nextMethod;
		611	}
		612	}
		613	} else {
		614	for (int j = 0; j < length; j++) {
		615	if (i == j) continue;
		616	ReferenceBinding declaringClass2 = methods[j].declaringClass;
		617	if (!declaringClass2.isInterface() && declaringClass.isSuperclassOf(declaringClass2)) {
		618	if (toSkip == null)
		619	toSkip = new int[length];
		620	toSkip[i] = -1;
		621	continue nextMethod;
		622	}
		623	}
		624	}
		625	}
		626	}
		627	return toSkip;
		628	}
576	boolean isAsVisible(MethodBinding newMethod, MethodBinding inheritedMethod) {	629	boolean isAsVisible(MethodBinding newMethod, MethodBinding inheritedMethod) {
577	if (inheritedMethod.modifiers == newMethod.modifiers) return true;	630	if (inheritedMethod.modifiers == newMethod.modifiers) return true;
578		631
Lines 624-632 Link Here
624	reporter.referenceContext = currentMethod.sourceMethod();	677	reporter.referenceContext = currentMethod.sourceMethod();
625	return reporter;	678	return reporter;
626	}	679	}
627	SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) {
628	return null; // noop in 1.4
629	}
630	/**	680	/**
631	* Return true and report an incompatibleReturnType error if currentMethod's	681	* Return true and report an incompatibleReturnType error if currentMethod's
632	* return type is strictly incompatible with inheritedMethod's, else return	682	* return type is strictly incompatible with inheritedMethod's, else return