### Eclipse Workspace Patch 1.0 #P org.eclipse.jdt.core Index: compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java =================================================================== RCS file: /home/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java,v retrieving revision 1.59 diff -u -r1.59 MethodVerifier15.java --- compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java 2 May 2006 19:19:08 -0000 1.59 +++ compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier15.java 19 May 2006 18:22:35 -0000 @@ -11,6 +11,7 @@ package org.eclipse.jdt.internal.compiler.lookup; import org.eclipse.jdt.internal.compiler.util.HashtableOfObject; +import org.eclipse.jdt.internal.compiler.util.SimpleSet; class MethodVerifier15 extends MethodVerifier { @@ -528,6 +529,71 @@ && inheritedMethod.returnType == existingMethod.returnType && super.isInterfaceMethodImplemented(inheritedMethod, existingMethod, superType); } +SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) { + ReferenceBinding[] interfacesToVisit = null; + int nextPosition = 0; + ReferenceBinding[] itsInterfaces = superInterfaces; + if (itsInterfaces != Binding.NO_SUPERINTERFACES) { + nextPosition = itsInterfaces.length; + interfacesToVisit = itsInterfaces; + } + + ReferenceBinding superType = superclass; + while (superType != null && superType.isValidBinding()) { + if ((itsInterfaces = superType.superInterfaces()) != Binding.NO_SUPERINTERFACES) { + if (interfacesToVisit == null) { + interfacesToVisit = itsInterfaces; + nextPosition = interfacesToVisit.length; + } else { + int itsLength = itsInterfaces.length; + if (nextPosition + itsLength >= interfacesToVisit.length) + System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition); + nextInterface : for (int a = 0; a < itsLength; a++) { + ReferenceBinding next = itsInterfaces[a]; + for (int b = 0; b < nextPosition; b++) + if (next == interfacesToVisit[b]) continue nextInterface; + interfacesToVisit[nextPosition++] = next; + } + } + } + superType = superType.superclass(); + } + + for (int i = 0; i < nextPosition; i++) { + superType = interfacesToVisit[i]; + if (superType.isValidBinding()) { + if ((itsInterfaces = superType.superInterfaces()) != Binding.NO_SUPERINTERFACES) { + int itsLength = itsInterfaces.length; + if (nextPosition + itsLength >= interfacesToVisit.length) + System.arraycopy(interfacesToVisit, 0, interfacesToVisit = new ReferenceBinding[nextPosition + itsLength + 5], 0, nextPosition); + nextInterface : for (int a = 0; a < itsLength; a++) { + ReferenceBinding next = itsInterfaces[a]; + for (int b = 0; b < nextPosition; b++) + if (next == interfacesToVisit[b]) continue nextInterface; + interfacesToVisit[nextPosition++] = next; + } + } + } + } + + SimpleSet copy = null; + for (int i = 0; i < nextPosition; i++) { + ReferenceBinding current = interfacesToVisit[i]; + if (current.isValidBinding()) { + TypeBinding erasure = current.erasure(); + for (int j = i + 1; j < nextPosition; j++) { + ReferenceBinding next = interfacesToVisit[j]; + if (next.isValidBinding() && next.erasure() == erasure) { + if (copy == null) + copy = new SimpleSet(nextPosition); + copy.add(interfacesToVisit[i]); + copy.add(interfacesToVisit[j]); + } + } + } + } + return copy; +} boolean reportIncompatibleReturnTypeError(MethodBinding currentMethod, MethodBinding inheritedMethod) { if (currentMethod.typeVariables == Binding.NO_TYPE_VARIABLES && inheritedMethod.original().typeVariables != Binding.NO_TYPE_VARIABLES Index: compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java =================================================================== RCS file: /home/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java,v retrieving revision 1.136 diff -u -r1.136 ClassScope.java --- compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java 28 Apr 2006 14:53:28 -0000 1.136 +++ compiler/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java 19 May 2006 18:22:35 -0000 @@ -625,36 +625,18 @@ // check for parameterized interface collisions (when different parameterizations occur) SourceTypeBinding sourceType = referenceContext.binding; ReferenceBinding[] interfaces = sourceType.superInterfaces; - int count = interfaces.length; Map invocations = new HashMap(2); ReferenceBinding itsSuperclass = sourceType.isInterface() ? null : sourceType.superclass; - nextInterface: for (int i = 0, length = count; i < length; i++) { + nextInterface: for (int i = 0, length = interfaces.length; i < length; i++) { ReferenceBinding one = interfaces[i]; if (one == null) continue nextInterface; - if (itsSuperclass != null && hasErasedCandidatesCollisions(itsSuperclass, one, invocations, sourceType, referenceContext)) { - interfaces[i] = null; - count--; + if (itsSuperclass != null && hasErasedCandidatesCollisions(itsSuperclass, one, invocations, sourceType, referenceContext)) continue nextInterface; - } nextOtherInterface: for (int j = 0; j < i; j++) { ReferenceBinding two = interfaces[j]; if (two == null) continue nextOtherInterface; - if (hasErasedCandidatesCollisions(one, two, invocations, sourceType, referenceContext)) { - interfaces[i] = null; - count--; + if (hasErasedCandidatesCollisions(one, two, invocations, sourceType, referenceContext)) continue nextInterface; - } - } - } - if (count < interfaces.length) { - if (count == 0) { - sourceType.superInterfaces = Binding.NO_SUPERINTERFACES; - } else { - ReferenceBinding[] newInterfaceBindings = new ReferenceBinding[count]; - for (int i = 0, j = 0, l = interfaces.length; i < l; i++) - if (interfaces[i] != null) - newInterfaceBindings[j++] = interfaces[i]; - sourceType.superInterfaces = newInterfaceBindings; } } Index: compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java =================================================================== RCS file: /home/eclipse/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java,v retrieving revision 1.78 diff -u -r1.78 MethodVerifier.java --- compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java 2 May 2006 19:46:54 -0000 1.78 +++ compiler/org/eclipse/jdt/internal/compiler/lookup/MethodVerifier.java 19 May 2006 18:22:35 -0000 @@ -16,6 +16,7 @@ import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; import org.eclipse.jdt.internal.compiler.problem.ProblemReporter; import org.eclipse.jdt.internal.compiler.util.HashtableOfObject; +import org.eclipse.jdt.internal.compiler.util.SimpleSet; public class MethodVerifier { SourceTypeBinding type; @@ -501,10 +502,13 @@ } superType = superType.superclass(); } + if (nextPosition == 0) return; + SimpleSet skip = findSuperinterfaceCollisions(superclass, superInterfaces); for (int i = 0; i < nextPosition; i++) { superType = interfacesToVisit[i]; if (superType.isValidBinding()) { + if (skip != null && skip.includes(superType)) continue; if ((itsInterfaces = superType.superInterfaces()) != Binding.NO_SUPERINTERFACES) { int itsLength = itsInterfaces.length; if (nextPosition + itsLength >= interfacesToVisit.length) @@ -614,6 +618,9 @@ reporter.referenceContext = currentMethod.sourceMethod(); return reporter; } +SimpleSet findSuperinterfaceCollisions(ReferenceBinding superclass, ReferenceBinding[] superInterfaces) { + return null; // noop in 1.4 +} boolean reportIncompatibleReturnTypeError(MethodBinding currentMethod, MethodBinding inheritedMethod) { problemReporter(currentMethod).incompatibleReturnType(currentMethod, inheritedMethod); return true; #P org.eclipse.jdt.core.tests.compiler Index: src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java =================================================================== RCS file: /home/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java,v retrieving revision 1.84 diff -u -r1.84 MethodVerifyTest.java --- src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java 21 Apr 2006 22:11:46 -0000 1.84 +++ src/org/eclipse/jdt/core/tests/compiler/regression/MethodVerifyTest.java 19 May 2006 18:22:41 -0000 @@ -5057,4 +5057,42 @@ "----------\n" ); } + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=142653 - variation + public void test088() { + this.runNegativeTest( + new String[] { + "X.java",//=================== + "import java.util.*;\n" + + "public class X extends ArrayList implements I,Runnable {\n" + + " \n" + + " void foo() {\n" + + " this.add(new Object());\n" + + " this.add(null);\n" + + " }\n" + + "}\n" + + "interface I extends Collection {\n" + + "}\n" , // =================, // ================= + }, + "----------\n" + + "1. ERROR in X.java (at line 2)\n" + + " public class X extends ArrayList implements I,Runnable {\n" + + " ^\n" + + "The interface Collection cannot be implemented more than once with different arguments: Collection and Collection\n" + + "----------\n" + + "2. ERROR in X.java (at line 2)\n" + + " public class X extends ArrayList implements I,Runnable {\n" + + " ^\n" + + "The type X must implement the inherited abstract method Runnable.run()\n" + + "----------\n" + + "3. WARNING in X.java (at line 2)\n" + + " public class X extends ArrayList implements I,Runnable {\n" + + " ^\n" + + "The serializable class X does not declare a static final serialVersionUID field of type long\n" + + "----------\n" + + "4. ERROR in X.java (at line 5)\n" + + " this.add(new Object());\n" + + " ^^^\n" + + "The method add(T0) in the type ArrayList is not applicable for the arguments (Object)\n" + + "----------\n"); + } } Index: src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java =================================================================== RCS file: /home/eclipse/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java,v retrieving revision 1.492 diff -u -r1.492 GenericTypeTest.java --- src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java 18 May 2006 15:28:25 -0000 1.492 +++ src/org/eclipse/jdt/core/tests/compiler/regression/GenericTypeTest.java 19 May 2006 18:22:41 -0000 @@ -31228,4 +31228,110 @@ "The return type is incompatible with AbstractEditPart.getViewer()\n" + "----------\n"); } +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=142653 +public void test0989() { + this.runNegativeTest( + new String[] { + "Child.java",//=================== + "public class Child extends Parent {}\n" + + "abstract class Parent extends Grandparent implements IParent {}\n" + + "interface IParent extends IGrandparent {}\n" + + "abstract class Grandparent implements IGrandparent {}\n" + + "interface IGrandparent {}", // =================, // ================= + }, + "----------\n" + + "1. ERROR in Child.java (at line 2)\n" + + " abstract class Parent extends Grandparent implements IParent {}\n" + + " ^^^^^^\n" + + "The interface IGrandparent cannot be implemented more than once with different arguments: IGrandparent and IGrandparent\n" + + "----------\n" + + "2. WARNING in Child.java (at line 2)\n" + + " abstract class Parent extends Grandparent implements IParent {}\n" + + " ^^^^^^^\n" + + "IParent is a raw type. References to generic type IParent should be parameterized\n" + + "----------\n"); +} +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=142653 - variation +public void test0990() { + this.runNegativeTest( + new String[] { + "Child.java",//=================== + "public class Child extends Parent {}\n" + + "abstract class Parent extends Grandparent implements IParent {}\n" + + "interface IParent extends IGrandparent {}\n" + + "abstract class Grandparent implements IGrandparent {}\n" + + "interface IGrandparent {}", // =================, // ================= + }, + "----------\n" + + "1. ERROR in Child.java (at line 1)\n" + + " public class Child extends Parent {}\n" + + " ^^^^^\n" + + "The hierarchy of the type Child is inconsistent\n" + + "----------\n" + + "2. ERROR in Child.java (at line 2)\n" + + " abstract class Parent extends Grandparent implements IParent {}\n" + + " ^^^^^^^\n" + + "The type Parent cannot extend or implement IParent. A supertype may not specify any wildcard\n" + + "----------\n"); +} +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=142653 - variation +public void test0991() { + this.runNegativeTest( + new String[] { + "X.java",//=================== + "public class X extends SX implements IX {}\n" + + "class SX extends TX implements IX {}\n" + + "class TX implements IX {}\n" + + "interface IX {}\n", // =================, // ================= + }, + "----------\n" + + "1. ERROR in X.java (at line 1)\n" + + " public class X extends SX implements IX {}\n" + + " ^\n" + + "The interface IX cannot be implemented more than once with different arguments: IX and IX\n" + + "----------\n" + + "2. ERROR in X.java (at line 2)\n" + + " class SX extends TX implements IX {}\n" + + " ^^\n" + + "The interface IX cannot be implemented more than once with different arguments: IX and IX\n" + + "----------\n"); +} +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=142653 - variation +public void test0992() { + this.runNegativeTest( + new String[] { + "X.java",//=================== + "import java.util.*;\n" + + "public abstract class X implements Collection, I {\n" + + " \n" + + " void foo() {\n" + + " this.add(new Object());\n" + + " this.add(null);\n" + + " }\n" + + "}\n" + + "interface I extends Collection {\n" + + "}\n", // =================, // ================= + }, + "----------\n" + + "1. ERROR in X.java (at line 2)\n" + + " public abstract class X implements Collection, I {\n" + + " ^\n" + + "The interface Collection cannot be implemented more than once with different arguments: Collection and Collection\n" + + "----------\n" + + "2. WARNING in X.java (at line 2)\n" + + " public abstract class X implements Collection, I {\n" + + " ^^^^^^^^^^\n" + + "Collection is a raw type. References to generic type Collection should be parameterized\n" + + "----------\n" + + "3. WARNING in X.java (at line 5)\n" + + " this.add(new Object());\n" + + " ^^^^^^^^^^^^^^^^^^^^^^\n" + + "Type safety: The method add(Object) belongs to the raw type Collection. References to generic type Collection should be parameterized\n" + + "----------\n" + + "4. WARNING in X.java (at line 6)\n" + + " this.add(null);\n" + + " ^^^^^^^^^^^^^^\n" + + "Type safety: The method add(Object) belongs to the raw type Collection. References to generic type Collection should be parameterized\n" + + "----------\n"); +} }