diff options
Diffstat (limited to 'org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java')
| -rw-r--r-- | org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java | 3531 |
1 files changed, 3531 insertions, 0 deletions
diff --git a/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java new file mode 100644 index 000000000..a83206608 --- /dev/null +++ b/org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AmbiguousMethodTest.java @@ -0,0 +1,3531 @@ +/******************************************************************************* + * Copyright (c) 2000, 2009 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.jdt.core.tests.compiler.regression; + +import java.util.Map; + +import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; + +import junit.framework.*; + +public class AmbiguousMethodTest extends AbstractComparableTest { + + public AmbiguousMethodTest(String name) { + super(name); + } + + public static Test suite() { + return buildComparableTestSuite(testClass()); + } + + public static Class testClass() { + return AmbiguousMethodTest.class; + } + + protected Map getCompilerOptions() { + Map compilerOptions = super.getCompilerOptions(); + compilerOptions.put(CompilerOptions.OPTION_ReportMissingOverrideAnnotationForInterfaceMethodImplementation, CompilerOptions.DISABLED); + return compilerOptions; + } + public void test000() { + this.runConformTest( + new String[] { + "Test.java", + "public class Test { public static void main(String[] args) { new B().foo(new C()); } }\n" + + "class A { void foo(A a) {} }\n" + + "class B extends A { void foo(B b) { System.out.println(1); } }\n" + + "class C extends B {}" + }, + "1" + ); + } + public void test000a() { + this.runConformTest( + new String[] { + "Test.java", + "public class Test { public static void main(String[] args) { new Subtype<String>().foo(1, \"works\"); } }\n" + + "class Supertype<T1> { <U1> void foo(U1 u, T1 t) {} }\n" + + "class Subtype <T2> extends Supertype<T2> { <U3> void foo(U3 u, T2 t) { System.out.println(t); } }" + }, + "works" + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=122881 + public void test001() { + this.runConformTest( + new String[] { + "C.java", + "public class C { public static void main(String[] args) { new B().m(\"works\"); } }\n" + + "class B extends A { @Override <T extends Comparable<T>> void m(T t) { System.out.println(t); } }\n" + + "abstract class A { abstract <T extends Comparable<T>> void m(T t); }" + }, + "works" + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=122881 + public void test002() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " static interface I1<E1> { void method(E1 o); }\n" + + " static interface I2<E2> { void method(E2 o); }\n" + + " static interface I3<E3, E4> extends I1<E3>, I2<E4> {}\n" + + " static class Class1 implements I3<String, String> {\n" + + " public void method(String o) { System.out.println(o); }\n" + + " }\n" + + " public static void main(String[] args) {\n" + + " I3<String, String> i = new Class1();\n" + + " i.method(\"works\");\n" + + " }\n" + + "}" + }, + "works" + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=122881 + public void test002a() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " static interface I1<E> { void method(E o); }\n" + + " static interface I2<E> { void method(E o); }\n" + + " static interface I3<E> extends I1<E>, I2<E> {}\n" + + " static class Class1 implements I3<String> {\n" + + " public void method(String o) { System.out.println(o); }\n" + + " }\n" + + " public static void main(String[] args) {\n" + + " I3<String> i = new Class1();\n" + + " i.method(\"works\");\n" + + " }\n" + + "}" + }, + "works" + ); + } + public void test003() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X { void foo() { new BB().test(); } }\n" + + "class AA<T> { void test() {} }\n" + + "class BB extends AA<CC> { <U> void test() {} }\n" + + "class CC {}\n", + }, + "----------\n" + + "1. ERROR in X.java (at line 1)\n" + + " public class X { void foo() { new BB().test(); } }\n" + + " ^^^^\n" + + "The method test() is ambiguous for the type BB\n" + + "----------\n" + + "2. ERROR in X.java (at line 3)\n" + + " class BB extends AA<CC> { <U> void test() {} }\n" + + " ^^^^^^\n" + + "Name clash: The method test() of type BB has the same erasure as test() of type AA<T> but does not override it\n" + + "----------\n" + ); + } + public void test003a() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " void singleMatch() { System.out.print(new BB().test(new N(), new Integer(1))); }\n" + + " void betterMatch() { System.out.print(new CC().test(new N(), new Integer(1))); }\n" + + " void worseMatch() { System.out.print(new DD().test(new N(), new Integer(1))); }\n" + + " public static void main(String[] s) {\n" + + " new X().singleMatch();\n" + + " new X().betterMatch();\n" + + " new X().worseMatch();\n" + + " }\n" + + "}\n" + + "class AA<T> { int test(T t, Number num) { return 1; } }\n" + + "class BB extends AA<N> { @Override int test(N n, Number num) { return 2; } }\n" + + "class CC extends AA<M> { <U extends Number> int test(N n, U u) { return 3; } }\n" + + "class DD extends AA<N> { <U extends Number> int test(M m, U u) { return 4; } }\n" + + "class M {}\n" + + "class N extends M {}", + }, + "231" + ); + } + public void test003b() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X {\n" + + " void ambiguous() { new BB().test(new N()); }\n" + + " void exactMatch() { new CC().test(new N()); }\n" + + "}\n" + + "class AA<T> { void test(T t) {} }\n" + + "class BB extends AA<N> { <U> void test(N n) {} }\n" + + "class CC extends AA<N> { @Override void test(N n) {} }\n" + + "class M {}\n" + + "class N extends M {}", + }, + "----------\n" + + "1. ERROR in X.java (at line 2)\r\n" + + " void ambiguous() { new BB().test(new N()); }\r\n" + + " ^^^^\n" + + "The method test(N) is ambiguous for the type BB\n" + + "----------\n" + ); + } + public void test003c() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X {\n" + + " void ambiguous() { new BB().test(new N(), new Integer(1)); }\n" + + "}\n" + + "class AA<T> { void test(T t, Integer i) {} }\n" + + "class BB extends AA<M> { <U extends Number> void test(N n, U u) {} }\n" + + "class M {}\n" + + "class N extends M {}", + }, + "----------\n" + + "1. ERROR in X.java (at line 2)\n" + + " void ambiguous() { new BB().test(new N(), new Integer(1)); }\n" + + " ^^^^\n" + + "The method test(N, Integer) is ambiguous for the type BB\n" + + "----------\n" + ); + } + public void test004() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X {\n" + + " void test(M<Integer> m) {\n" + + " m.id(new Integer(111));\n" + + " }\n" + + "}\n" + + "class C<T extends Number> { public void id(T t) {} }\n" + + "class M<TT> extends C<Integer> { public <ZZ> void id(Integer i) {} }\n" + }, + "----------\n" + + "1. ERROR in X.java (at line 3)\n" + + " m.id(new Integer(111));\n" + + " ^^\n" + + "The method id(Integer) is ambiguous for the type M<Integer>\n" + + "----------\n" + // reference to id is ambiguous, both method id(A) in C<java.lang.Integer> and method id(B) in M<java.lang.Integer,java.lang.Integer> match + ); + } + public void test004a() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " void test(M<Integer> m) {\n" + + " m.id(new Integer(111));\n" + + " }\n" + + "}\n" + + "class C<T extends Number> { public void id(T t) {} }\n" + + "class M<TT> extends C<Integer> { public void id(Integer i) {} }\n" + }, + "" + ); + } + public void test005() { + // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6182950 + this.runNegativeTest( + new String[] { + "X.java", + "public class X {\n" + + " <S extends A> void foo() { }\n" + + " <N extends B> N foo() { return null; }\n" + + " void test () {\n" + + " new X().foo();\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B {}\n" + }, + "----------\n" + + "1. ERROR in X.java (at line 2)\n" + + " <S extends A> void foo() { }\n" + + " ^^^^^\n" + + "Duplicate method foo() in type X\n" + + "----------\n" + + "2. ERROR in X.java (at line 3)\n" + + " <N extends B> N foo() { return null; }\n" + + " ^^^^^\n" + + "Duplicate method foo() in type X\n" + + "----------\n" + ); +/* javac 7 +X.java:3: name clash: <N>foo() and <S>foo() have the same erasure + <N extends B> N foo() { return null; } + ^ + where N,S are type-variables: + N extends B declared in method <N>foo() + S extends A declared in method <S>foo() +1 error + */ + } + public void test006() { + // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6182950 + this.runNegativeTest( + new String[] { + "X.java", + "public class X<T> {\n" + + " void test() {\n" + + " new Y<Object>().foo(\"X\");\n" + + " new Y<Object>().foo2(\"X\");\n" + + " }\n" + + " <U1> U1 foo(U1 t) {return null;}\n" + + " <U2> U2 foo2(U2 t) {return null;}\n" + + "}\n" + + "class Y<T2> extends X<T2> {\n" + + " void foo(T2 t) {}\n" + + " <U3> void foo2(T2 t) {}\n" + + "}\n" + }, + "----------\n" + + "1. ERROR in X.java (at line 3)\n" + + " new Y<Object>().foo(\"X\");\n" + + " ^^^\n" + + "The method foo(Object) is ambiguous for the type Y<Object>\n" + + "----------\n" + + "2. ERROR in X.java (at line 4)\n" + + " new Y<Object>().foo2(\"X\");\n" + + " ^^^^\n" + + "The method foo2(Object) is ambiguous for the type Y<Object>\n" + + "----------\n" + + "3. ERROR in X.java (at line 10)\n" + + " void foo(T2 t) {}\n" + + " ^^^^^^^^^\n" + + "Name clash: The method foo(T2) of type Y<T2> has the same erasure as foo(U1) of type X<T> but does not override it\n" + + "----------\n" + + "4. ERROR in X.java (at line 11)\n" + + " <U3> void foo2(T2 t) {}\n" + + " ^^^^^^^^^^\n" + + "Name clash: The method foo2(T2) of type Y<T2> has the same erasure as foo2(U2) of type X<T> but does not override it\n" + + "----------\n" + ); +/* javac 7 +X.java:3: reference to foo is ambiguous, both method <U1>foo(U1) in X and method + foo(T2) in Y match + new Y<Object>().foo("X"); + ^ + where U1,T2 are type-variables: + U1 extends Object declared in method <U1>foo(U1) + T2 extends Object declared in class Y +X.java:4: reference to foo2 is ambiguous, both method <U2>foo2(U2) in X and meth +od <U3>foo2(T2) in Y match + new Y<Object>().foo2("X"); + ^ + where U2,U3,T2 are type-variables: + U2 extends Object declared in method <U2>foo2(U2) + U3 extends Object declared in method <U3>foo2(T2) + T2 extends Object declared in class Y +X.java:10: name clash: foo(T2) in Y and <U1>foo(U1) in X have the same erasure, +yet neither overrides the other + void foo(T2 t) {} + ^ + where T2,U1 are type-variables: + T2 extends Object declared in class Y + U1 extends Object declared in method <U1>foo(U1) +X.java:11: name clash: <U3>foo2(T2) in Y and <U2>foo2(U2) in X have the same era +sure, yet neither overrides the other + <U3> void foo2(T2 t) {} + ^ + where U3,T2,U2 are type-variables: + U3 extends Object declared in method <U3>foo2(T2) + T2 extends Object declared in class Y + U2 extends Object declared in method <U2>foo2(U2) +4 errors + */ + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=129056 + public void test007() { + this.runNegativeTest( + new String[] { + "B.java", + "public class B {\n" + + " public static void main(String[] args) {\n" + + " new M().foo(new Integer(1), 2);\n" + + " new N().foo(new Integer(1), 2);\n" + + " }\n" + + "}" + + "interface I { void foo(Number arg1, Number arg2); }\n" + + "class M {\n" + + " public void foo(int arg1, int arg2) {}\n" + + " public void foo(Number arg1, Number arg2) {}\n" + + "}\n" + + "class N implements I {\n" + + " public void foo(int arg1, int arg2) {}\n" + + " public void foo(Number arg1, Number arg2) {}\n" + + "}\n" + }, + "----------\n" + + "1. ERROR in B.java (at line 3)\r\n" + + " new M().foo(new Integer(1), 2);\r\n" + + " ^^^\n" + + "The method foo(int, int) is ambiguous for the type M\n" + + "----------\n" + + "2. ERROR in B.java (at line 4)\r\n" + + " new N().foo(new Integer(1), 2);\r\n" + + " ^^^\n" + + "The method foo(int, int) is ambiguous for the type N\n" + + "----------\n" + // reference to foo is ambiguous, both method foo(int,int) in M and method foo(java.lang.Number,java.lang.Number) in M match + // reference to foo is ambiguous, both method foo(int,int) in N and method foo(java.lang.Number,java.lang.Number) in N match + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=123943 - case 1 + public void test008() { + this.runConformTest( + new String[] { + "AA.java", + "public class AA {\n" + + " public static void main(String[] a) { System.out.print(new C().test(new T())); }\n" + + "}" + + "class S {}\n" + + "class T extends S {}\n" + + "class B { <U extends S> int test(U u) {return -1;} }\n" + + "class C extends B { @Override int test(S s) {return 1;} }" + }, + "1" + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=123943 - case 1 + public void test008a() { + this.runNegativeTest( + new String[] { + "A.java", + "public class A { void check() { new C().test(new T()); } }\n" + + "class S {}\n" + + "class T extends S {}\n" + + "class B { int test(S s) {return 1;} }\n" + + "class C extends B { <U extends S> int test(U u) {return -1;} }" + }, + "----------\n" + + "1. ERROR in A.java (at line 1)\n" + + " public class A { void check() { new C().test(new T()); } }\n" + + " ^^^^\n" + + "The method test(T) is ambiguous for the type C\n" + + "----------\n" + + "2. ERROR in A.java (at line 5)\n" + + " class C extends B { <U extends S> int test(U u) {return -1;} }\n" + + " ^^^^^^^^^\n" + + "Name clash: The method test(U) of type C has the same erasure as test(S) of type B but does not override it\n" + + "----------\n" + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=123943 - case 2 + public void test009() { + this.runConformTest( + new String[] { + "T.java", + "import java.util.*;\n" + + "public class T {\n" + + " void test() {\n" + + " OrderedSet<String> os = null;\n" + + " os.add(\"hello\");\n" + + " OrderedSet<Integer> os2 = null;\n" + + " os2.add(1);\n" + + " }\n" + + "}" + + "interface OrderedSet<E> extends List<E>, Set<E> { boolean add(E o); }\n" + }, + "" + ); + } +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=121024 +public void test010a() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X {\n" + + " interface Listener {}\n" + + " interface ErrorListener {}\n" + + " static <L1 extends Listener & ErrorListener> Object createParser(L1 l) { return null; }\n" + + " static <L2 extends ErrorListener & Listener> Object createParser(L2 l) { return null; }\n" + + " public static void main(String[] s) {\n" + + " class A implements Listener, ErrorListener {}\n" + + " createParser(new A());\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in X.java (at line 8)\n" + + " createParser(new A());\n" + + " ^^^^^^^^^^^^\n" + + "The method createParser(A) is ambiguous for the type X\n" + + "----------\n" + ); +// javac 7 randomly picks which ever method is second +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=121024 +public void test010b() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " interface Listener {}\n" + + " interface ErrorListener {}\n" + + " static <L1 extends Listener> int createParser(L1 l) { return 1; }\n" + + " static <L2 extends ErrorListener & Listener> int createParser(L2 l) { return 2; }\n" + + " public static void main(String[] s) {\n" + + " class A implements Listener, ErrorListener {}\n" + + " System.out.print(createParser(new A()));\n" + + " }\n" + + "}" + }, + "2" + ); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=121024 +public void test010c() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " interface Listener {}\n" + + " interface ErrorListener {}\n" + + " static int createParser(Listener l) { return 1; }\n" + + " static <L extends ErrorListener & Listener> int createParser(L l) { return 2; }\n" + + " public static void main(String[] s) {\n" + + " class A implements Listener, ErrorListener {}\n" + + " System.out.print(createParser(new A()));\n" + + " }\n" + + "}" + }, + "2" + ); +} + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=106090 + public void test011() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X<A extends Number> extends Y<A> {\n" + + " <T> void foo(A n, T t) throws ExOne {}\n" + + " void test(X<Integer> x) throws ExTwo { x.foo(new Integer(1), new Integer(2)); }\n" + + " void test2(X x) throws ExTwo { x.foo(new Integer(1), new Integer(2)); }\n" + + "}\n" + + "class Y<C extends Number> {\n" + + " void foo(C x, C n) throws ExTwo {}\n" + + "}\n" + + "class ExOne extends Exception {static final long serialVersionUID = 1;}\n" + + "class ExTwo extends Exception {static final long serialVersionUID = 2;}" + }, + "----------\n" + + "1. WARNING in X.java (at line 4)\n" + + " void test2(X x) throws ExTwo { x.foo(new Integer(1), new Integer(2)); }\n" + + " ^\n" + + "X is a raw type. References to generic type X<A> should be parameterized\n" + + "----------\n" + + "2. WARNING in X.java (at line 4)\n" + + " void test2(X x) throws ExTwo { x.foo(new Integer(1), new Integer(2)); }\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Type safety: The method foo(Number, Number) belongs to the raw type Y. References to generic type Y<C> should be parameterized\n" + + "----------\n" + // test2 - warning: [unchecked] unchecked call to foo(C,C) as a member of the raw type Y + ); + } + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=106090 + public void test011a() { + // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6182950 + this.runNegativeTest( + new String[] { + "Combined.java", + "public class Combined<A, B> {\n" + + " <T extends Comparable<T>> void pickOne(T value) throws ExOne {}\n" + + " <T> T pickOne(Comparable<T> value) throws ExTwo { return null;}\n" + + " void pickOne(Combined<Integer,Integer> c) throws ExOne { c.pickOne(\"test\"); }\n" + + " <T extends Number> void pickTwo(Number n, T t) throws ExOne {}\n" + + " void pickTwo(A x, Number n) throws ExTwo {}\n" + + " void pickTwo(Combined<Integer,Integer> c) throws ExTwo { c.pickTwo(new Integer(1), 2); }\n" + + "}\n" + + "class ExOne extends Exception {static final long serialVersionUID = 1;}\n" + + "class ExTwo extends Exception {static final long serialVersionUID = 2;}" + }, + "----------\n" + + "1. ERROR in Combined.java (at line 2)\n" + + " <T extends Comparable<T>> void pickOne(T value) throws ExOne {}\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Method pickOne(T) has the same erasure pickOne(Comparable<T>) as another method in type Combined<A,B>\n" + + "----------\n" + + "2. ERROR in Combined.java (at line 3)\n" + + " <T> T pickOne(Comparable<T> value) throws ExTwo { return null;}\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Method pickOne(Comparable<T>) has the same erasure pickOne(Comparable<T>) as another method in type Combined<A,B>\n" + + "----------\n" + ); +/* javac 7 +X.java:3: name clash: <T#1>pickOne(Comparable<T#1>) and <T#2>pickOne(T#2) have the same erasure + <T> T pickOne(Comparable<T> value) throws ExTwo { return null;} + ^ + where T#1,T#2 are type-variables: + T#1 extends Object declared in method <T#1>pickOne(Comparable<T#1>) + T#2 extends Comparable<T#2> declared in method <T#2>pickOne(T#2) +1 error + */ + } + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=106090 + public void test011b() { + // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6182950 + this.runNegativeTest( + new String[] { + "Test1.java", + "public class Test1<AA, BB> {\n" + + " <T extends Comparable<T>> void pickOne(T value) throws ExOne {}\n" + + " <T> T pickOne(Comparable<T> value) throws ExTwo { return null;}\n" + + " void pickOne2(Test1<Integer,Integer> c) throws ExOne { c.pickOne((Comparable) \"test\"); }\n" + + "}\n" + + "class ExOne extends Exception {static final long serialVersionUID = 1;}\n" + + "class ExTwo extends Exception {static final long serialVersionUID = 2;}" + }, + "----------\n" + + "1. ERROR in Test1.java (at line 2)\n" + + " <T extends Comparable<T>> void pickOne(T value) throws ExOne {}\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Method pickOne(T) has the same erasure pickOne(Comparable<T>) as another method in type Test1<AA,BB>\n" + + "----------\n" + + "2. ERROR in Test1.java (at line 3)\n" + + " <T> T pickOne(Comparable<T> value) throws ExTwo { return null;}\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Method pickOne(Comparable<T>) has the same erasure pickOne(Comparable<T>) as another method in type Test1<AA,BB>\n" + + "----------\n" + + "3. WARNING in Test1.java (at line 4)\n" + + " void pickOne2(Test1<Integer,Integer> c) throws ExOne { c.pickOne((Comparable) \"test\"); }\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Type safety: Unchecked invocation pickOne(Comparable) of the generic method pickOne(T) of type Test1<Integer,Integer>\n" + + "----------\n" + + "4. WARNING in Test1.java (at line 4)\n" + + " void pickOne2(Test1<Integer,Integer> c) throws ExOne { c.pickOne((Comparable) \"test\"); }\n" + + " ^^^^^^^^^^\n" + + "Comparable is a raw type. References to generic type Comparable<T> should be parameterized\n" + + "----------\n" + ); +/* javac 7 +X.java:3: name clash: <T#1>pickOne(Comparable<T#1>) and <T#2>pickOne(T#2) have the same erasure + <T> T pickOne(Comparable<T> value) throws ExTwo { return null;} + ^ + where T#1,T#2 are type-variables: + T#1 extends Object declared in method <T#1>pickOne(Comparable<T#1>) + T#2 extends Comparable<T#2> declared in method <T#2>pickOne(T#2) +X.java:4: warning: [unchecked] unchecked method invocation: method pickOne in class Test1 is applied to given types + void pickOne2(Test1<Integer,Integer> c) throws ExOne { c.pickOne((Comparable) "test"); } + ^ + required: T + found: Comparable + where T is a type-variable: + T extends Comparable<T> declared in method <T>pickOne(T) +1 error +1 warning + */ + } + public void test012() { + this.runConformTest( + new String[] { + "XX.java", + "public class XX {\n" + + " public static void main(String[] s) { System.out.println(new B().id(new Integer(1))); }\n" + + "}\n" + + "class A<T extends Number> { public int id(T t) {return 2;} }\n" + + "class B extends A<Integer> { public int id(Integer i) {return 1;} }" + }, + "1" + ); + } + public void test012a() { + this.runNegativeTest( + new String[] { + "XX.java", + "public class XX {\n" + + " public static void main(String[] s) { System.out.println(new B().id(new Integer(1))); }\n" + + "}\n" + + "class A<T extends Number> { public int id(T t) {return 2;} }\n" + + "class B extends A<Integer> { public <ZZ> int id(Integer i) {return 1;} }" + }, + "----------\n" + + "1. ERROR in XX.java (at line 2)\r\n" + + " public static void main(String[] s) { System.out.println(new B().id(new Integer(1))); }\r\n" + + " ^^\n" + + "The method id(Integer) is ambiguous for the type B\n" + + "----------\n" + // reference to id is ambiguous, both method id(T) in A<java.lang.Integer> and method <ZZ>id(java.lang.Integer) in B match + ); + } + public void test013() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " <E extends A> void m(E e) { System.out.print(1); }\n" + + " <E extends B> void m(E e) { System.out.print(2); }\n" + + " public static void main(String[] args) {\n" + + " new X().m(new A());\n" + + " new X().m(new B());\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + }, + "12" + ); + } + public void test014() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " void a(G x) { System.out.print(1); }\n" + + " void b(F x) { System.out.print(2); }\n" + + " public static void main(String[] args) {\n" + + " H<C> h = null;\n" + + " G<C> g = null;\n" + + " new X().a(h);\n" + + " new X().a(g);\n" + + " new X().b(h);\n" + + " new X().b(g);\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "1122" + ); + } + public void test014a() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " void a(G<C> x) { System.out.print(1); }\n" + + " void b(F<C> x) { System.out.print(2); }\n" + + " public static void main(String[] args) {\n" + + " H h = null;\n" + + " G g = null;\n" + + " new X().a(h);\n" + + " new X().a(g);\n" + + " new X().b(h);\n" + + " new X().b(g);\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "1122" + ); + } + public void test014b() { + this.runConformTest( + new String[] { + "X0.java", + "public class X0 {\n" + + " void two(G x) { System.out.print(1); }\n" + + " void two(F<A> x) { System.out.print(2); }\n" + + " void three(G x) { System.out.print(3); }\n" + + " void three(F<B> x) { System.out.print(4); }\n" + + " public static void main(String[] args) {\n" + + " H<C> h = null;\n" + + " new X0().two(h);\n" + + " new X0().three(h);\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "13" + ); + } + public void test014c() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X {\n" + + " void a(G x) {}\n" + + " void a(F<C> x) {}\n" + + " void b(G<C> x) {}\n" + + " void b(F x) {}\n" + + " public static void main(String[] args) {\n" + + " H<C> h = null;\n" + + " new X().a(h);\n" + + " new X().b(h);\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "----------\n" + + "1. WARNING in X.java (at line 2)\r\n" + + " void a(G x) {}\r\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 5)\r\n" + + " void b(F x) {}\r\n" + + " ^\n" + + "F is a raw type. References to generic type F<T1> should be parameterized\n" + + "----------\n" + + "3. ERROR in X.java (at line 8)\r\n" + + " new X().a(h);\r\n" + + " ^\n" + + "The method a(G) is ambiguous for the type X\n" + + "----------\n" + // reference to a is ambiguous, both method a(G) in X and method a(F<C>) in X match + ); + } + public void test014d() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X {\n" + + " void one(G<B> x) {}\n" + + " void one(F<B> x) {}\n" + + " public static void main(String[] args) {\n" + + " H<C> h = null;\n" + + " new X().one(h);\n" + // no match + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "----------\n" + + "1. ERROR in X.java (at line 6)\r\n" + + " new X().one(h);\r\n" + + " ^^^\n" + + "The method one(G<B>) in the type X is not applicable for the arguments (H<C>)\n" + + "----------\n" + ); + } + public void test014e() { + this.runConformTest( + new String[] { + "X1.java", + "public class X1 {\n" + + " void two(G<C> x) { System.out.print(1); }\n" + + " void two(F<B> x) { System.out.print(2); }\n" + + " void three(G<B> x) { System.out.print(3); }\n" + + " void three(F<C> x) { System.out.print(4); }\n" + + " void four(G<C> x) { System.out.print(5); }\n" + + " void four(F<C> x) { System.out.print(6); }\n" + + " public static void main(String[] args) {\n" + + " H<C> h = null;\n" + + " new X1().two(h);\n" + + " new X1().three(h);\n" + + " new X1().four(h);\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "145" + ); + } + public void test014f() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X {\n" + + " <E1, E2 extends B> void three(G<E2> x) {}\n" + + " <E3 extends C> void three(F<E3> x) {}\n" + + " public static void main(String[] args) {\n" + + " H<C> h = null;\n" + + " new X().three(h);\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "----------\n" + + "1. ERROR in X.java (at line 6)\r\n" + + " new X().three(h);\r\n" + + " ^^^^^\n" + + "The method three(G<C>) is ambiguous for the type X\n" + + "----------\n" + ); + } + public void test014g() { + this.runConformTest( + new String[] { + "X3.java", + "public class X3 {\n" + + " <E1, E2 extends B> void one(G<E2> x) { System.out.print(1); }\n" + + " <E3 extends B> void one(F<E3> x) { System.out.print(2); }\n" + + " <E1, E2 extends C> void two(G<E2> x) { System.out.print(3); }\n" + + " <E3 extends B> void two(F<E3> x) { System.out.print(4); }\n" + + " <E1, E2 extends C> void four(G<E2> x) { System.out.print(5); }\n" + + " <E3 extends C> void four(F<E3> x) { System.out.print(6); }\n" + + " public static void main(String[] args) {\n" + + " H<C> h = null;\n" + + " new X3().one(h);\n" + + " new X3().two(h);\n" + + " new X3().four(h);\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "135" + ); + } + public void test014h() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " void x(G x) { System.out.print(true); }\n" + + " void x(F x) { System.out.print(false); }\n" + + " void x2(G<C> x) { System.out.print(true); }\n" + + " void x2(F<C> x) { System.out.print(false); }\n" + + " void a(G x) {}\n" + + " void a(F<C> x) {}\n" + + " void a2(G x) {}\n" + + " <T extends C> void a2(F<T> x) {}\n" + + " void a3(G x) {}\n" + + " <T extends F<C>> void a3(T x) {}\n" + + " void a4(G x) {}\n" + + " <T extends C, S extends F<T>> void a4(S x) {}\n" + + " <T extends G> void a5(T x) {}\n" + + " void a5(F<C> x) {}\n" + + " <T extends G> void a6(T x) {}\n" + + " <T extends C, S extends F<T>> void a6(S x) {}\n" + + " void b(G<C> x) { System.out.print(true); }\n" + + " void b(F x) { System.out.print(false); }\n" + + " void b2(G<C> x) { System.out.print(true); }\n" + + " <T extends F> void b2(T x) { System.out.print(false); }\n" + + " <T extends C> void b3(G<T> x) { System.out.print(true); }\n" + + " void b3(F x) { System.out.print(false); }\n" + + " <T extends G<C>> void b4(T x) { System.out.print(true); }\n" + + " void b4(F x) { System.out.print(false); }\n" + + " <T extends C, S extends G<T>> void b5(S x) { System.out.print(true); }\n" + + " void b5(F x) { System.out.print(false); }\n" + + " void c(G x) { System.out.print(true); }\n" + + " <T extends C> void c(F x) { System.out.print(false); }\n" + + " public static void main(String[] args) {\n" + + " H<C> h = null;\n" + + " H hraw = null;\n" + + " new X().x(h);\n" + + " new X().x(hraw);\n" + + " new X().x2(h);\n" + + " new X().x2(hraw);\n" + + " new X().b(h);\n" + + " new X().b(hraw);\n" + + " new X().b2(h);\n" + + " new X().b2(hraw);\n" + + " new X().b3(h);\n" + + " new X().b3(hraw);\n" + + " new X().b4(h);\n" + + " new X().b4(hraw);\n" + + " new X().b5(h);\n" + + " new X().b5(hraw);\n" + + " new X().c(h);\n" + + " new X().c(hraw);\n" + + " }\n" + + "}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "class C extends B {}\n" + + "class F<T1> {} \n" + + "class G<T2> extends F<T2> {}\n" + + "class H<T3> extends G<T3> {}" + }, + "truetruetruetruetruetruetruetruetruetruetruetruetruetruetruetrue" + ); + this.runNegativeTest( + new String[] { + "Y.java", + "public class Y extends X {\n" + + " public static void ambiguousCases() {\n" + + " H<C> h = null;\n" + + " H hraw = null;\n" + + " new X().a(h);\n" + + " new X().a(hraw);\n" + + " new X().a2(h);\n" + + " new X().a2(hraw);\n" + + " new X().a3(h);\n" + + " new X().a3(hraw);\n" + + " new X().a4(h);\n" + + " new X().a4(hraw);\n" + + " new X().a5(h);\n" + + " new X().a5(hraw);\n" + + " new X().a6(h);\n" + + " new X().a6(hraw);\n" + + " }\n" + + "}\n" + }, + "----------\n" + + "1. WARNING in Y.java (at line 4)\n" + + " H hraw = null;\n" + + " ^\n" + + "H is a raw type. References to generic type H<T3> should be parameterized\n" + + "----------\n" + + "2. ERROR in Y.java (at line 5)\n" + + " new X().a(h);\n" + + " ^\n" + + "The method a(G) is ambiguous for the type X\n" + + "----------\n" + + "3. ERROR in Y.java (at line 6)\n" + + " new X().a(hraw);\n" + + " ^\n" + + "The method a(G) is ambiguous for the type X\n" + + "----------\n" + + "4. ERROR in Y.java (at line 7)\n" + + " new X().a2(h);\n" + + " ^^\n" + + "The method a2(G) is ambiguous for the type X\n" + + "----------\n" + + "5. ERROR in Y.java (at line 8)\n" + + " new X().a2(hraw);\n" + + " ^^\n" + + "The method a2(G) is ambiguous for the type X\n" + + "----------\n" + + "6. ERROR in Y.java (at line 9)\n" + + " new X().a3(h);\n" + + " ^^\n" + + "The method a3(G) is ambiguous for the type X\n" + + "----------\n" + + "7. ERROR in Y.java (at line 10)\n" + + " new X().a3(hraw);\n" + + " ^^\n" + + "The method a3(G) is ambiguous for the type X\n" + + "----------\n" + + "8. ERROR in Y.java (at line 11)\n" + + " new X().a4(h);\n" + + " ^^\n" + + "The method a4(G) is ambiguous for the type X\n" + + "----------\n" + + "9. ERROR in Y.java (at line 12)\n" + + " new X().a4(hraw);\n" + + " ^^\n" + + "The method a4(G) is ambiguous for the type X\n" + + "----------\n" + + "10. ERROR in Y.java (at line 13)\n" + + " new X().a5(h);\n" + + " ^^\n" + + "The method a5(H<C>) is ambiguous for the type X\n" + + "----------\n" + + "11. ERROR in Y.java (at line 14)\n" + + " new X().a5(hraw);\n" + + " ^^\n" + + "The method a5(H) is ambiguous for the type X\n" + + "----------\n" + + "12. ERROR in Y.java (at line 15)\n" + + " new X().a6(h);\n" + + " ^^\n" + + "The method a6(H<C>) is ambiguous for the type X\n" + + "----------\n" + + "13. ERROR in Y.java (at line 16)\n" + + " new X().a6(hraw);\n" + + " ^^\n" + + "The method a6(H) is ambiguous for the type X\n" + + "----------\n", + null, + 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( + new String[] { + "E.java", + "public class E {\n" + + " public static void main(String[] s) {\n" + + " IJ ij = new K();\n" + + " try { ij.m(); } catch(E11 e) {}\n" + + " }\n" + + "}\n" + + "interface I { void m() throws E1; }\n" + + "interface J { void m() throws E11; }\n" + + "interface IJ extends I, J {}\n" + + "class K implements IJ { public void m() {} }\n" + + "class E1 extends Exception { static final long serialVersionUID = 1; }\n" + + "class E11 extends E1 { static final long serialVersionUID = 2; }\n" + + "class E2 extends Exception { static final long serialVersionUID = 3; }" + }, + "" + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=79798 + public void _test016() { + this.runConformTest( + new String[] { + "E.java", + "public class E {\n" + + " public static void main(String[] s) {\n" + + " IJ ij = new K();\n" + + " try { ij.m(); } catch(E11 e) {}\n" + + " }\n" + + "}\n" + + "interface I { void m() throws E1; }\n" + + "interface J { void m() throws E2, E11; }\n" + + "interface IJ extends I, J {}\n" + + "class K implements IJ { public void m() {} }\n" + + "class E1 extends Exception { static final long serialVersionUID = 1; }\n" + + "class E11 extends E1 { static final long serialVersionUID = 2; }\n" + + "class E2 extends Exception { static final long serialVersionUID = 3; }" + }, + "" + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=79798 + public void _test016a() { + this.runNegativeTest( + new String[] { + "E.java", + "public class E {\n" + + " public static void main(String[] s) {\n" + + " IJ ij = new K();\n" + + " ij.m();\n" + + " try { ij.m(); } catch(E2 e) {}\n" + + " }\n" + + "}\n" + + "interface I { void m() throws E1; }\n" + + "interface J { void m() throws E2, E11; }\n" + + "interface IJ extends I, J {}\n" + + "class K implements IJ { public void m() {} }\n" + + "class E1 extends Exception { static final long serialVersionUID = 1; }\n" + + "class E11 extends E1 { static final long serialVersionUID = 2; }\n" + + "class E2 extends Exception { static final long serialVersionUID = 3; }" + }, + "----------\n" + + "1. ERROR in E.java (at line 4)\r\n" + + " ij.m();\r\n" + + " ^^^^^^\n" + + "Unhandled exception type E11\n" + + "----------\n" + + "2. ERROR in E.java (at line 5)\r\n" + + " try { ij.m(); } catch(E2 e) {}\r\n" + + " ^^^^^^\n" + + "Unhandled exception type E11\n" + + "----------\n" + + "3. ERROR in E.java (at line 5)\r\n" + + " try { ij.m(); } catch(E2 e) {}\r\n" + + " ^^\n" + + "Unreachable catch block for E2. This exception is never thrown from the try statement body\n" + + "----------\n" + // 4: unreported exception E11; must be caught or declared to be thrown + // 5: exception E2 is never thrown in body of corresponding try statement + // 5: unreported exception E11; must be caught or declared to be thrown + ); + } + //https://bugs.eclipse.org/bugs/show_bug.cgi?id=149893 + public void test017() { + this.runConformTest( + new String[] { + "AbstractFilter.java", + "import java.util.*;\n" + + "public class AbstractFilter<T> implements IFilter<T> {\n" + + " public final <E extends T> boolean selekt(E obj) { return true; }\n" + + " public final <E extends T> List<E> filter(List<E> elements) {\n" + + " if ((elements == null) || (elements.size() == 0)) return elements;\n" + + " List<E> okElements = new ArrayList<E>(elements.size());\n" + + " for (E obj : elements) {\n" + + " if (selekt(obj)) okElements.add(obj);\n" + + " }\n" + + " return okElements;" + + " }\n" + + "}\n" + + "interface IFilter<T> {\n" + + " <E extends T> boolean selekt(E obj);\n" + + " <E extends T> List<E> filter(List<E> elements);\n" + + "}" + }, + "" + ); + } + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=147647 + public void test018() { + this.runConformTest( + new String[] { + "Y.java", + "class X<T extends Object> {\n" + + " public static <U extends Object> X<U> make(Class<U> clazz) {\n" + + " System.out.print(false);\n" + + " return new X<U>();\n" + + " }\n" + + "}\n" + + "public class Y<V extends String> extends X<V> {\n" + + " public static <W extends String> Y<W> make(Class<W> clazz) {\n" + + " System.out.print(true);\n" + + " return new Y<W>();\n" + + " }\n" + + " public static void main(String[] args) throws Exception {\n" + + " Y.make(String.class);\n" + + " }\n" + + "}" + }, + "true"); + } + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=147647 + // in fact, <W extends String> Y<W> make(Class<W> clazz) is the most + // specific method according to JLS 15.12.2.5 + public void test019() { + this.runConformTest( + new String[] { + "Y.java", + "class X<T extends Object> {\n" + + " public static <U extends Object> X<U> make(Class<U> clazz) {\n" + + " System.out.print(false);\n" + + " return new X<U>();\n" + + " }\n" + + "}\n" + + "public class Y<V extends String> extends X<V> {\n" + + " public static <W extends String> Y<W> make(Class<W> clazz) {\n" + + " System.out.print(true);\n" + + " return new Y<W>();\n" + + " }\n" + + " public static void main(String[] args) throws Exception {\n" + + " Y.make(getClazz());\n" + + " }\n" + + " public static Class getClazz() {\n" + + " return String.class;\n" + + " }\n" + + "}" + }, + "true"); + } + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=147647 + public void test020() { + this.runConformTest( + new String[] { + "Y.java", + "class X<T extends Object> {\n" + + " public static <U extends Object> X<U> make(Class<U> clazz) {\n" + + " System.out.print(true);\n" + + " return new X<U>();\n" + + " }\n" + + "}\n" + + "public class Y<V extends String> extends X<V> {\n" + + " public static <W extends String> Y<W> make(Class<W> clazz) {\n" + + " System.out.print(false);\n" + + " return new Y<W>();\n" + + " }\n" + + " public static void main(String[] args) throws Exception {\n" + + " Y.make(getClazz().newInstance().getClass());\n" + + " }\n" + + " public static Class getClazz() {\n" + + " return String.class;\n" + + " }\n" + + "}" + }, + "true"); + } + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=147647 + // variant: having both methods in the same class should not change anything + public void test021() { + // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6182950 + this.runNegativeTest( + new String[] { + "Y.java", + "class X<T extends Object> {\n" + + "}\n" + + "public class Y<V extends String> extends X<V> {\n" + + " public static <W extends String> Y<W> make(Class<W> clazz) {\n" + + " System.out.print(true);\n" + + " return new Y<W>();\n" + + " }\n" + + " public static <U extends Object> X<U> make(Class<U> clazz) {\n" + + " System.out.print(false);\n" + + " return new X<U>();\n" + + " }\n" + + " public static void main(String[] args) throws Exception {\n" + + " Y.make(getClazz());\n" + + " }\n" + + " public static Class getClazz() {\n" + + " return String.class;\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. WARNING in Y.java (at line 3)\n" + + " public class Y<V extends String> extends X<V> {\n" + + " ^^^^^^\n" + + "The type parameter V should not be bounded by the final type String. Final types cannot be further extended\n" + + "----------\n" + + "2. WARNING in Y.java (at line 4)\n" + + " public static <W extends String> Y<W> make(Class<W> clazz) {\n" + + " ^^^^^^\n" + + "The type parameter W should not be bounded by the final type String. Final types cannot be further extended\n" + + "----------\n" + + "3. ERROR in Y.java (at line 4)\n" + + " public static <W extends String> Y<W> make(Class<W> clazz) {\n" + + " ^^^^^^^^^^^^^^^^^^^^\n" + + "Method make(Class<W>) has the same erasure make(Class<T>) as another method in type Y<V>\n" + + "----------\n" + + "4. ERROR in Y.java (at line 8)\n" + + " public static <U extends Object> X<U> make(Class<U> clazz) {\n" + + " ^^^^^^^^^^^^^^^^^^^^\n" + + "Method make(Class<U>) has the same erasure make(Class<T>) as another method in type Y<V>\n" + + "----------\n" + + "5. WARNING in Y.java (at line 13)\n" + + " Y.make(getClazz());\n" + + " ^^^^^^^^^^^^^^^^^^\n" + + "Type safety: Unchecked invocation make(Class) of the generic method make(Class<W>) of type Y\n" + + "----------\n" + + "6. WARNING in Y.java (at line 13)\n" + + " Y.make(getClazz());\n" + + " ^^^^^^^^^^\n" + + "Type safety: The expression of type Class needs unchecked conversion to conform to Class<String>\n" + + "----------\n" + + "7. WARNING in Y.java (at line 15)\n" + + " public static Class getClazz() {\n" + + " ^^^^^\n" + + "Class is a raw type. References to generic type Class<T> should be parameterized\n" + + "----------\n" + ); +/* javac 7 +X.java:8: name clash: <U>make(Class<U>) and <W>make(Class<W>) have the same erasure + public static <U extends Object> X<U> make(Class<U> clazz) { + ^ + where U,W are type-variables: + U extends Object declared in method <U>make(Class<U>) + W extends String declared in method <W>make(Class<W>) +X.java:13: warning: [unchecked] unchecked conversion + Y.make(getClazz()); + ^ + required: Class<W#1> + found: Class + where W#1,W#2 are type-variables: + W#1 extends String declared in method <W#2>make(Class<W#2>) + W#2 extends String declared in method <W#2>make(Class<W#2>) +X.java:13: warning: [unchecked] unchecked method invocation: method make in class Y is applied to given types + Y.make(getClazz()); + ^ + required: Class<W> + found: Class + where W is a type-variable: + W extends String declared in method <W>make(Class<W>) +1 error +2 warnings + */ + } + // https://bugs.eclipse.org/bugs/show_bug.cgi?id=147647 + // variant: using instances triggers raw methods, which are ambiguous + public void test022() { + // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6182950 + this.runNegativeTest( + new String[] { + "X.java", + "public class X<T extends Object> {\n" + + "}\n" + + "class Y<V extends String> extends X<V> {\n" + + " public <W extends String> Y<W> make(Class<W> clazz) {\n" + + " return new Y<W>();\n" + + " }\n" + + " public <U extends Object> X<U> make(Class<U> clazz) {\n" + + " return new X<U>();\n" + + " }\n" + + " public static void main(String[] args) throws Exception {\n" + + " Y y = new Y();\n" + + " y.make(String.class);\n" + + " y.make(getClazz());\n" + + " y.make(getClazz().newInstance().getClass());\n" + + " }\n" + + " public static Class getClazz() {\n" + + " return String.class;\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. WARNING in X.java (at line 3)\n" + + " class Y<V extends String> extends X<V> {\n" + + " ^^^^^^\n" + + "The type parameter V should not be bounded by the final type String. Final types cannot be further extended\n" + + "----------\n" + + "2. WARNING in X.java (at line 4)\n" + + " public <W extends String> Y<W> make(Class<W> clazz) {\n" + + " ^^^^^^\n" + + "The type parameter W should not be bounded by the final type String. Final types cannot be further extended\n" + + "----------\n" + + "3. ERROR in X.java (at line 4)\n" + + " public <W extends String> Y<W> make(Class<W> clazz) {\n" + + " ^^^^^^^^^^^^^^^^^^^^\n" + + "Method make(Class<W>) has the same erasure make(Class<T>) as another method in type Y<V>\n" + + "----------\n" + + "4. ERROR in X.java (at line 7)\n" + + " public <U extends Object> X<U> make(Class<U> clazz) {\n" + + " ^^^^^^^^^^^^^^^^^^^^\n" + + "Method make(Class<U>) has the same erasure make(Class<T>) as another method in type Y<V>\n" + + "----------\n" + + "5. WARNING in X.java (at line 11)\n" + + " Y y = new Y();\n" + + " ^\n" + + "Y is a raw type. References to generic type Y<V> should be parameterized\n" + + "----------\n" + + "6. WARNING in X.java (at line 11)\n" + + " Y y = new Y();\n" + + " ^\n" + + "Y is a raw type. References to generic type Y<V> should be parameterized\n" + + "----------\n" + + "7. WARNING in X.java (at line 12)\n" + + " y.make(String.class);\n" + + " ^^^^^^^^^^^^^^^^^^^^\n" + + "Type safety: The method make(Class) belongs to the raw type Y. References to generic type Y<V> should be parameterized\n" + + "----------\n" + + "8. WARNING in X.java (at line 13)\n" + + " y.make(getClazz());\n" + + " ^^^^^^^^^^^^^^^^^^\n" + + "Type safety: The method make(Class) belongs to the raw type Y. References to generic type Y<V> should be parameterized\n" + + "----------\n" + + "9. WARNING in X.java (at line 14)\n" + + " y.make(getClazz().newInstance().getClass());\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Type safety: The method make(Class) belongs to the raw type Y. References to generic type Y<V> should be parameterized\n" + + "----------\n" + + "10. WARNING in X.java (at line 16)\n" + + " public static Class getClazz() {\n" + + " ^^^^^\n" + + "Class is a raw type. References to generic type Class<T> should be parameterized\n" + + "----------\n" + ); +/* javac 7 +X.java:7: name clash: <U>make(Class<U>) and <W>make(Class<W>) have the same erasure + public <U extends Object> X<U> make(Class<U> clazz) { + ^ + where U,W are type-variables: + U extends Object declared in method <U>make(Class<U>) + W extends String declared in method <W>make(Class<W>) +X.java:12: warning: [unchecked] unchecked call to <W>make(Class<W>) as a member of the raw type Y + y.make(String.class); + ^ + where W is a type-variable: + W extends String declared in method <W>make(Class<W>) +X.java:13: warning: [unchecked] unchecked call to <W>make(Class<W>) as a member of the raw type Y + y.make(getClazz()); + ^ + where W is a type-variable: + W extends String declared in method <W>make(Class<W>) +X.java:14: warning: [unchecked] unchecked call to <W>make(Class<W>) as a member of the raw type Y + y.make(getClazz().newInstance().getClass()); + ^ + where W is a type-variable: + W extends String declared in method <W>make(Class<W>) +1 error +3 warnings + */ + } +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=159711 +public void test023() { + this.runConformTest( + new String[] { + "X.java", + "import java.util.*;\n" + + "public class X {\n" + + " public static void staticFoo(Collection<?> p) {\n" + + " System.out.print(1);\n" + + " }\n" + + " public static <T extends List<?>> void staticFoo(T p) {\n" + + " System.out.print(2);\n" + + " }\n" + + " public void foo(Collection<?> p) {\n" + + " System.out.print(1);\n" + + " }\n" + + " public <T extends List<?>> void foo(T p) {\n" + + " System.out.print(2);\n" + + " }\n" + + " public void foo2(Collection<?> p) {\n" + + " System.out.print(1);\n" + + " }\n" + + " public void foo2(List<?> p) {\n" + + " System.out.print(2);\n" + + " }\n" + + " public static void main(String[] args) {\n" + + " staticFoo(new ArrayList<String>(Arrays.asList(\"\")));\n" + + " new X().foo(new ArrayList<String>(Arrays.asList(\"\")));\n" + + " new X().foo2(new ArrayList<String>(Arrays.asList(\"\")));\n" + + " }\n" + + "}" + }, + "222"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=159711 +// self contained variant +public void test024() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " public static void foo(L1<?> p) {\n" + + " System.out.println(1);\n" + + " }\n" + + " public static <T extends L2<?>> void foo(T p) {\n" + + " System.out.println(2);\n" + + " }\n" + + " public static void main(String[] args) {\n" + + " foo(new L3<String>());\n" + + " }\n" + + "}", + "L1.java", + "public interface L1<T> {\n" + + "}", + "L2.java", + "public interface L2<T> extends L1<T> {\n" + + "}", + "L3.java", + "public class L3<T> implements L2<T> {\n" + + " public L3() {\n" + + " }\n" + + "}", + }, + "2"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162026 +public void test025() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " J m = new Y();\n" + + " void foo() {\n" + + " m.foo(1.0f);\n" + + " }\n" + + "}", + "I.java", + "public interface I {\n" + + " <T extends Number> T foo(final Number p);\n" + + "}", + "J.java", + "public interface J extends I {\n" + + " Float foo(final Number p);\n" + + "}", + "Y.java", + "public class Y implements J {\n" + + " public Float foo(final Number p){\n" + + " return null;\n" + + " }\n" + + "}", + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162026 +// variant +public void test026() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " void foo() {\n" + + " (new Y()).foo(1.0f);\n" + + " }\n" + + "}", + "I.java", + "public interface I {\n" + + " <T extends Number> T foo(final Number p);\n" + + "}", + "J.java", + "public interface J extends I {\n" + + " Float foo(final Number p);\n" + + "}", + "Y.java", + "public class Y implements J {\n" + + " public Float foo(final Number p){\n" + + " return null;" + + " }\n" + + "}", + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162026 +// variant +public void test027() { + this.runNegativeTest( + new String[] { + "J.java", + "public interface J {\n" + + " <T extends Number> T foo(final Number p);\n" + + " Float foo(final Number p);\n" + + "}", + }, + "----------\n" + + "1. ERROR in J.java (at line 2)\n" + + " <T extends Number> T foo(final Number p);\n" + + " ^^^^^^^^^^^^^^^^^^^\n" + + "Duplicate method foo(Number) in type J\n" + + "----------\n" + + "2. ERROR in J.java (at line 3)\n" + + " Float foo(final Number p);\n" + + " ^^^^^^^^^^^^^^^^^^^\n" + + "Duplicate method foo(Number) in type J\n" + + "----------\n"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +public void test028() { + this.runConformTest( + new String[] { /* test files */ + "X.java", + "interface Irrelevant {}\n" + + "interface I {\n" + + " Object foo(Number n);\n" + + "}\n" + + "interface J extends Irrelevant, I {\n" + + " String foo(Number n);\n" + + "}\n" + + "interface K {\n" + + " Object foo(Number n);\n" + + "}\n" + + "public abstract class X implements J, K {\n" + + " void foo() {\n" + + " foo(0.0f);\n" + + " }\n" + + "}" + }, + JavacTestOptions.JavacHasABug.JavacBug6294779 /* javac test options */); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - simplified +public void test029() { + this.runConformTest( + new String[] { /* test files */ + "X.java", + "interface J {\n" + + " String foo(Number n);\n" + + "}\n" + + "interface K {\n" + + " Object foo(Number n);\n" + + "}\n" + + "public abstract class X implements J, K {\n" + + " void foo() {\n" + + " foo(0.0f);\n" + + " }\n" + + "}" + }, + JavacTestOptions.JavacHasABug.JavacBug6294779 /* javac test options */); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - same return type +public void test030() { + this.runConformTest( + new String[] { + "X.java", + "interface J {\n" + + " Object foo(Number n);\n" + + "}\n" + + "interface K {\n" + + " Object foo(Number n);\n" + + "}\n" + + "public abstract class X implements J, K {\n" + + " void foo() {\n" + + " foo(0.0f);\n" + + " }\n" + + "}" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant +public void test031() { + this.runConformTest( + new String[] { /* test files */ + "X.java", + "interface Irrelevant {}\n" + + "interface I {\n" + + " Object foo(Number n);\n" + + "}\n" + + "interface J extends Irrelevant, I {\n" + + " String foo(Number n);\n" + + "}\n" + + "interface K {\n" + + " Object foo(Number n);\n" + + "}\n" + + "public abstract class X implements Irrelevant, I, J, K {\n" + + " void foo() {\n" + + " foo(0.0f);\n" + + " }\n" + + "}" + }, + JavacTestOptions.JavacHasABug.JavacBug6294779 /* javac test options */); +} +// tests 32-34 were moved to MethodVerifyTest 134-140 + +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - the inheriting class implements foo +public void test035() { + this.runConformTest( + new String[] { + "X.java", + "interface I {\n" + + " Object foo(Number n);\n" + + "}\n" + + "abstract class J {\n" + + " abstract String foo(Number n);\n" + + "}\n" + + "public class X extends J implements I {\n" + + " void bar() {\n" + + " foo(0.0f);\n" + // calls X#foo(Number) + " }\n" + + " public String foo(Number n) {\n" + + " return null;\n" + + " }\n" + + "}" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - extending instead of implementing +public void test037() { + this.runConformTest( + // test directory preparation + new String[] { /* test files */ + "X.java", + "interface I {\n" + + " Object foo(Number n);\n" + + "}\n" + + "abstract class J {\n" + + " abstract String foo(Number n);\n" + + "}\n" + + "public abstract class X extends J implements I {\n" + + " void bar() {\n" + + " foo(0.0f);\n" + + " }\n" + + "}" + }, + // javac options + JavacTestOptions.JavacHasABug.JavacBug6294779 /* javac test options */); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - no promotion of parameter from float to Number +public void test038() { + this.runConformTest( + new String[] { /* test files */ + "X.java", + "interface I {\n" + + " Object foo(float f);\n" + + "}\n" + + "abstract class J {\n" + + " public abstract String foo(float f);\n" + + "}\n" + + "public abstract class X extends J implements I {\n" + + " void bar() {\n" + + " foo(0.0f);\n" + + " }\n" + + "}" + }, + JavacTestOptions.JavacHasABug.JavacBug6294779 /* javac test options */); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - an explicit cast solves the issue +public void test039() { + this.runConformTest( + new String[] { + "X.java", + "interface I {\n" + + " Object foo(float f);\n" + + "}\n" + + "abstract class J {\n" + + " public abstract String foo(float f);\n" + + "}\n" + + "public abstract class X extends J implements I {\n" + + " void bar() {\n" + + " String s = ((J) this).foo(0.0f);\n" + + " }\n" + + "}" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - an explicit cast solves the issue +public void test040() { + this.runConformTest( + new String[] { + "X.java", + "interface I {\n" + + " Object foo(float f);\n" + + "}\n" + + "abstract class J {\n" + + " public abstract String foo(float f);\n" + + "}\n" + + "public abstract class X extends J implements I {\n" + + " void bar() {\n" + + " Object o = ((I) this).foo(0.0f);\n" + + " }\n" + + "}" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - connecting return types +public void test041() { + this.runNegativeTest( + new String[] { + "X.java", + "interface I {\n" + + " Object foo(float f);\n" + + "}\n" + + "abstract class J {\n" + + " public abstract String foo(float f);\n" + + "}\n" + + "public abstract class X extends J implements I {\n" + + " void bar() {\n" + + " String s = ((I) this).foo(0.0f);\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in X.java (at line 9)\n" + + " String s = ((I) this).foo(0.0f);\n" + + " ^^^^^^^^^^^^^^^^^^^^\n" + + "Type mismatch: cannot convert from Object to String\n" + + "----------\n"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - a further inheriting class implements String foo +public void test042() { + this.runConformTest( + // test directory preparation + new String[] { /* test files */ + "X.java", + "interface I {\n" + + " Object foo(float f);\n" + + "}\n" + + "abstract class J {\n" + + " public abstract String foo(float f);\n" + + "}\n" + + "public abstract class X extends J implements I {\n" + + " void bar() {\n" + + " foo(0.0f);\n" + + " }\n" + + "}\n" + + "class Z extends X {\n" + + " @Override" + + " public String foo(float f) {\n" + + " return null;\n" + + " }\n" + + "}" + }, + // javac options + JavacTestOptions.JavacHasABug.JavacBug6294779 /* javac test options */); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=162065 +// variant - a further inheriting class implements Object foo +public void test043() { + this.runNegativeTest( + new String[] { + "X.java", + "interface I {\n" + + " Object foo(float f);\n" + + "}\n" + + "abstract class J {\n" + + " public abstract String foo(float f);\n" + + "}\n" + + "public abstract class X extends J implements I {\n" + + " void bar() {\n" + + " foo(0.0f);\n" + + " }\n" + + "}\n" + + "class Z extends X {\n" + + " @Override\n" + + " public Object foo(float f) {\n" + // cannot override String foo + " return null;\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in X.java (at line 14)\n" + + " public Object foo(float f) {\n" + + " ^^^^^^\n" + + "The return type is incompatible with J.foo(float)\n" + + "----------\n"); +} + +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=163370 +public void test044() { + this.runConformTest( + new String[] { + "X.java", + "interface I<E> {}\n" + + "class Y<E> {}\n" + + "public class X<E extends Y<E>> implements I<E> {\n" + + " public static <E extends Y<E>> X<E> bar(X<E> s) {\n" + + " return null;\n" + + " }\n" + + " public static <E extends Y<E>> X<E> bar(I<E> c) {\n" + + " return null;\n" + + " }\n" + + " public static <E extends Y<E>> X<E> foo(X<E> s) {\n" + + " X<E> result = bar(s);\n" + + " return result;\n" + + " }\n" + + "}" + }, + ""); +} + +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=165620 +public void test045() { + this.runConformTest( + new String[] { + "X.java", + "abstract class Y<T> implements I<T> {\n" + + "}\n" + + "interface I<T> { \n" + + "}\n" + + "interface J<T> {\n" + + "}\n" + + "class X {\n" + + " public static <V extends J<? super V>> V foo(final I<V> a)\n" + + " {\n" + + " return null;\n" + + " }\n" + + " public static <V extends J<? super V>> V foo(final Y<V> a)\n" + + " {\n" + + " return null;\n" + + " }\n" + + " public static <V extends J<? super V>> void test(final Y<V> a)\n" + + " {\n" + + " foo(a);\n" + + " }\n" + + "}" + }, + ""); +} + +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=163370 +// variant +public void test046() { + this.runConformTest( + new String[] { + "X.java", + "abstract class Y<T, U> implements I<T, U> {\n" + + "}\n" + + "interface I<T, U> { \n" + + "}\n" + + "interface J<T, U> {\n" + + "}\n" + + "class X {\n" + + " public static <V extends J<V, W>, W extends J<V, W>> V foo(final I<V, W> a)\n" + + " {\n" + + " return null;\n" + + " }\n" + + " public static <V extends J<V, W>, W extends J<V, W>> V foo(final Y<V, W> a)\n" + + " {\n" + + " return null;\n" + + " }\n" + + " public static <V extends J<V, W>, W extends J<V, W>> void test(final Y<V, W> a)\n" + + " {\n" + + " foo(a);\n" + + " }\n" + + "}" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=163590 +public void test047() { + this.runNegativeTest( + // test directory preparation + new String[] { /* test files */ + "X.java", + "public class X<T extends I & J> {\n" + + " void foo(T t) {\n" + + " }\n" + + "}\n" + + "interface I {\n" + + " public int method();\n" + + "}\n" + + "interface J {\n" + + " public boolean method();\n" + + "}\n" + }, + // compiler results + "----------\n" + /* expected compiler log */ + "1. ERROR in X.java (at line 1)\n" + + " public class X<T extends I & J> {\n" + + " ^\n" + + "The return types are incompatible for the inherited methods J.method(), I.method()\n" + + "----------\n", + // javac options + JavacTestOptions.JavacHasABug.JavacBug5061359 /* javac test options */); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=163590 +// Variant: javac complains as well if we attempt to use method, but noone +// complains upon bar or CONSTANT. +public void test048() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X<T extends I & J> {\n" + + " void foo(T t) {\n" + + " t.method();\n" + + " t.bar();\n" + + " if (t.CONSTANT > 0);\n" + + " }\n" + + "}\n" + + "interface I {\n" + + " public int method();\n" + + " void bar();\n" + + "}\n" + + "interface J {\n" + + " public boolean method();\n" + + " static final int CONSTANT = 0;\n" + + "}\n" + }, + "----------\n" + + "1. ERROR in X.java (at line 1)\n" + + " public class X<T extends I & J> {\n" + + " ^\n" + + "The return types are incompatible for the inherited methods J.method(), I.method()\n" + + "----------\n" + + "2. ERROR in X.java (at line 3)\n" + + " t.method();\n" + + " ^^^^^^\n" + + "The method method() is ambiguous for the type T\n" + + "----------\n" + + "3. WARNING in X.java (at line 5)\n" + + " if (t.CONSTANT > 0);\n" + + " ^^^^^^^^\n" + + "The static field J.CONSTANT should be accessed in a static way\n" + + "----------\n"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=163590 +// can't implement both interfaces though +public void test049() { + this.runNegativeTest( + new String[] { + "X.java", + "interface I {\n" + + " public int method();\n" + + "}\n" + + "interface J {\n" + + " public boolean method();\n" + + "}\n" + + "class X implements I, J {\n" + + " public int method() {\n" + + " return 0;\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in X.java (at line 8)\n" + + " public int method() {\n" + + " ^^^\n" + + "The return type is incompatible with J.method()\n" + + "----------\n"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=163590 +// variant: secure the legal case +public void test050() { + this.runConformTest( + new String[] { + "X.java", + "public class X<T extends I & J> {\n" + + " void foo(T t) {\n" + + " }\n" + + "}\n" + + "interface I {\n" + + " public int method();\n" + + "}\n" + + "interface J {\n" + + " public int method();\n" + + "}\n" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=166355 +public void test051() { + this.runNegativeTest( + new String[] { /* test files */ + "X.java", + "interface I<T> {\n" + + "}\n" + + "class Y {\n" + + " void bar(I<?> x) {\n" + + " }\n" + + "}\n" + + "public class X extends Y {\n" + + " void foo() {\n" + + " bar(new Z());\n" + + " }\n" + + " void bar(Z x) {\n" + + " }\n" + + " private static final class Z implements I {\n" + + " }\n" + + "}\n" + }, + "----------\n" + + "1. ERROR in X.java (at line 9)\n" + + " bar(new Z());\n" + + " ^^^\n" + + "The method bar(X.Z) is ambiguous for the type X\n" + + "----------\n" + + "2. WARNING in X.java (at line 13)\n" + + " private static final class Z 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=166355 +// variant +public void test052() { + this.runConformTest( + new String[] { + "X.java", + "interface I<T> {\n" + + "}\n" + + "class Y {\n" + + " void bar(I<?> x) {\n" + + " }\n" + + "}\n" + + "public class X extends Y {\n" + + " void foo() {\n" + + " bar(new Z());\n" + + " }\n" + + " void bar(Z x) {\n" + + " }\n" + + " private static final class Z implements I<String> {\n" + + " }\n" + + "}\n" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=166355 +// variant +public void test053() { + this.runNegativeTest( + new String[] { /* test files */ + "X.java", + "interface I<T> {\n" + + "}\n" + + "class Y {\n" + + " void bar(I<?> x) {\n" + + " }\n" + + "}\n" + + "public class X extends Y {\n" + + " void foo() {\n" + + " bar(new Z(){});\n" + + " }\n" + + " void bar(Z x) {\n" + + " }\n" + + " private static class Z implements I {\n" + + " }\n" + + "}\n" + }, + "----------\n" + + "1. ERROR in X.java (at line 9)\n" + + " bar(new Z(){});\n" + + " ^^^\n" + + "The method bar(X.Z) is ambiguous for the type X\n" + + "----------\n" + + "2. WARNING in X.java (at line 13)\n" + + " private static class Z 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=166355 +// variant +public void test054() { + this.runConformTest( + new String[] { + "X.java", + "public class X {\n" + + " void bar(Z x) {\n" + + " System.out.println(\"bar(Z)\");\n" + + " }\n" + + " void bar(I<?> x) {\n" + + " System.out.println(\"bar(I)\");\n" + + " }\n" + + " public static void main(String args[]) {\n" + + " (new X()).bar(new Z());\n" + + " }\n" + + "}\n" + + "interface I<T> {}\n" + + "class Z implements I<Object> {}" + }, + "bar(Z)"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=166355 +// variant +public void _test055() { + this.runNegativeTest( + new String[] { + "X.java", + "interface I<T> {}\n" + + "class X {\n" + + " void bar(Z x) {\n" + + " System.out.println(\"bar(Z)\");\n" + + " }\n" + + " void bar(I<?> x) {\n" + + " System.out.println(\"bar(I)\");\n" + + " }\n" + + " public static void main(String args[]) {\n" + + " (new X()).bar(new Z());\n" + + " }\n" + + "}\n" + + "class Z implements I {}" + }, + "ERR"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=184190 +public void test056() { + this.runConformTest( + new String[] { + "X.java", + "public class X<T> {\n" + + " void bar(X x) {\n" + + " ZA z = ZA.foo(x);\n" + + " z.toString();\n" + + " }\n" + + "}\n" + + "class Y<T> {\n" + + " public static <U> Y<U> foo(X<U> x) {\n" + + " return null;\n" + + " }\n" + + "}\n" + + "class YA<T extends A> extends Y<T> {\n" + + " public static <U extends A> YA<U> foo(X<U> x) {\n" + + " return (YA<U>) Y.foo(x);\n" + + " }\n" + + "}\n" + + "class ZA<T extends B> extends YA<T> {\n" + + " public static <U extends B> ZA<U> foo(X<U> x) {\n" + + " return (ZA<U>) Y.foo(x);\n" + + " }\n" + + "}\n" + + "abstract class A {\n" + + "}\n" + + "abstract class B extends A {\n" + + "}" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=186382 +public void test057() { + this.runConformTest( + new String[] { + "X.java", + "public class X extends Y {\n" + + " @Override <T4, G4 extends I<T4>> T4 foo(G4 g) { return super.foo(g); }\n" + + "}\n" + + "class Y extends Z {\n" + + " @Override <T3, G3 extends I<T3>> T3 foo(G3 g) { return super.foo(g); }\n" + + "}\n" + + "class Z {\n" + + " <T2, G2 extends I<T2>> T2 foo(G2 g) { return null; }\n" + + "}\n" + + "interface I<T1> {}" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=188741 +public void test058() { + this.runConformTest( + new String[] { + "X.java", + "public class X extends A {\n" + + " void x(G g) { System.out.print(1); }\n" + + " void x(G g, G g2) { System.out.print(1); }\n" + + " public static void main(String[] s) {\n" + + " H h = new H();\n" + + " new X().x(h);\n" + + " new X().x(h, h);\n" + + " }\n" + + "}\n" + + "class A<T> {\n" + + " void x(T t) { System.out.print(2); }\n" + + " <U> void x(T t, U u) { System.out.print(2); }\n" + + "}\n" + + "class F<T> {}\n" + + "class G<T> extends F<T> {}\n" + + "class H<T> extends G<T> {}" + }, + "11"); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=188741 +public void test058a() { + this.runConformTest( + new String[] { + "X.java", + "public class X extends java.util.ArrayList {\n" + + " private static final long serialVersionUID = 1L;\n" + + " public void add(Comparable o) {}\n" + + " public void test() { add(\"hello\"); }\n" + + "}" + }, + ""); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=188960 +public void test059() { + this.runNegativeTest( + new String[] { + "X.java", + "class X<T> {\n" + + " X() {}\n" + + " X(String s) {}\n" + + " X(T t) {}\n" + + " void foo(String s) {}\n" + + " void foo(T t) {}\n" + + "}\n" + + "class NoErrorSubclass extends X<String> {}\n" + + "class StringOnlySubClass extends X<String> {\n" + + " StringOnlySubClass(String s) { super(s); }\n" + + " @Override void foo(String s) { super.foo(s); }\n" + + "}\n" + + "class Test {\n" + + " Object o = new X<String>(\"xyz\");\n" + + " void test(X<String> x) { x.foo(\"xyz\"); }\n" + + "}" + }, + // no error is reported against duplicate constructors - but the call is reported as ambiguous + "----------\n" + + "1. ERROR in X.java (at line 8)\n" + + " class NoErrorSubclass extends X<String> {}\n" + + " ^^^^^^^^^^^^^^^\n" + + "Duplicate methods named foo with the parameters (T) and (String) are defined by the type X<String>\n" + + "----------\n" + + "2. ERROR in X.java (at line 10)\n" + + " StringOnlySubClass(String s) { super(s); }\n" + + " ^^^^^^^^^\n" + + "The constructor X<String>(String) is ambiguous\n" + + "----------\n" + + "3. ERROR in X.java (at line 11)\n" + + " @Override void foo(String s) { super.foo(s); }\n" + + " ^^^\n" + + "The method foo(String) is ambiguous for the type X<String>\n" + + "----------\n" + + "4. ERROR in X.java (at line 14)\n" + + " Object o = new X<String>(\"xyz\");\n" + + " ^^^^^^^^^^^^^^^^^^^^\n" + + "The constructor X<String>(String) is ambiguous\n" + + "----------\n" + + "5. ERROR in X.java (at line 15)\n" + + " void test(X<String> x) { x.foo(\"xyz\"); }\n" + + " ^^^\n" + + "The method foo(String) is ambiguous for the type X<String>\n" + + "----------\n" + ); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=191029 +public void test059a() { + this.runNegativeTest( + new String[] { + "X.java", + "import java.util.TreeMap;\n" + + "class X {\n" + + " void test(TreeMap<String, Object> tm) {\n" + + " TreeMap copy = new TreeMap(tm);\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. WARNING in X.java (at line 4)\n" + + " TreeMap copy = new TreeMap(tm);\n" + + " ^^^^^^^\n" + + "TreeMap is a raw type. References to generic type TreeMap<K,V> should be parameterized\n" + + "----------\n" + + "2. WARNING in X.java (at line 4)\n" + + " TreeMap copy = new TreeMap(tm);\n" + + " ^^^^^^^^^^^^^^^\n" + + "Type safety: The constructor TreeMap(SortedMap) belongs to the raw type TreeMap. References to generic type TreeMap<K,V> should be parameterized\n" + + "----------\n" + + "3. WARNING in X.java (at line 4)\n" + + " TreeMap copy = new TreeMap(tm);\n" + + " ^^^^^^^\n" + + "TreeMap is a raw type. References to generic type TreeMap<K,V> should be parameterized\n" + + "----------\n" + ); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=189933 +public void test060() { + this.runConformTest( + new String[] { + "X.java", + "public class X<T> {\n" + + " public void bar(K<T, Object> p) {\n" + + " new Y(p);\n" + + " new Y((J<T, Object>) p);\n" + + " new Y((I<T, Object>) p);\n" + + " }\n" + + "}\n" + + "class Y<T, U> {\n" + + " Y(I<? extends T, ? extends U> p) {}\n" + + " Y(J<T, ? extends U> p) {}\n" + + "}\n" + + "interface I<T, U> {}\n" + + "interface J<T, U> extends I<T, U> {}\n" + + "interface K<T, U> extends I<T, U>, J<T, U> {}" + }, + "" + ); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=189933 +// variant +public void test061() { + this.runNegativeTest( + new String[] { + "X.java", + "public class X<T> {\n" + + " public void bar(K<T, Object> p) {\n" + + " new Y(p);\n" + + " new Y((J<T, Object>) p);\n" + + " new Y((I<T, Object>) p);\n" + + " }\n" + + "}\n" + + "class Y<T, U> {\n" + + " Y(I<? extends T, ? extends U> p) {}\n" + + " Y(J<T, ? extends U> p) {}\n" + + "}\n" + + "interface I<T, U> {}\n" + + "interface J<T, U> {}\n" + + "interface K<T, U> extends I<T, U>, J<T, U> {}" + }, + "----------\n" + + "1. ERROR in X.java (at line 3)\n" + + " new Y(p);\n" + + " ^^^^^^^^\n" + + "The constructor Y(I) is ambiguous\n" + + "----------\n" + + "2. WARNING in X.java (at line 3)\n" + + " new Y(p);\n" + + " ^\n" + + "Y is a raw type. References to generic type Y<T,U> should be parameterized\n" + + "----------\n" + + "3. WARNING in X.java (at line 4)\n" + + " new Y((J<T, Object>) p);\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Type safety: The constructor Y(J) belongs to the raw type Y. References to generic type Y<T,U> should be parameterized\n" + + "----------\n" + + "4. WARNING in X.java (at line 4)\n" + + " new Y((J<T, Object>) p);\n" + + " ^\n" + + "Y is a raw type. References to generic type Y<T,U> should be parameterized\n" + + "----------\n" + + "5. WARNING in X.java (at line 5)\n" + + " new Y((I<T, Object>) p);\n" + + " ^^^^^^^^^^^^^^^^^^^^^^^\n" + + "Type safety: The constructor Y(I) belongs to the raw type Y. References to generic type Y<T,U> should be parameterized\n" + + "----------\n" + + "6. WARNING in X.java (at line 5)\n" + + " new Y((I<T, Object>) p);\n" + + " ^\n" + + "Y is a raw type. References to generic type Y<T,U> should be parameterized\n" + + "----------\n" + ); +} + +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=193265 +public void test062() { + this.runConformTest( + new String[] { + "X.java", + "enum E implements I {\n" + + " F;\n" + + "}\n" + + "interface I {}\n" + + "interface Spec {\n" + + " <T1 extends Enum<T1> & I> void method(T1 t);\n" + + "}\n" + + "abstract class X implements Spec {\n" + + " public <T2 extends Enum<T2> & I> void method(T2 t) {}\n" + + " void test() { method(E.F); }\n" + + "}" + }, + "" + ); +} + +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=196254 +public void test063() { + this.runConformTest( + new String[] { + "Test.java", + "interface I<R> {}\n" + + "class X<T extends I> {\n" + + " void method(X<?> that) {}\n" + + "}\n" + + "class Y<T extends I> extends X<T> {\n" + + " @Override void method(X<? extends I> that) { System.out.print(1); }\n" + + "}\n" + + "public class Test {\n" + + " public static void main(String[] args) { new Y().method((X) null); }\n" + + "}" + }, + "1" + ); +} + +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=198120 +public void test064() { + this.runConformTest( + new String[] { + "A.java", + "interface I<E> {\n" + + " void x(I<? extends E> i);\n" + + "}\n" + + "public abstract class A implements I {\n" + + " public void x(I i) {}\n" + + "}\n" + + "class B extends A {\n" + + " void y(A a) { super.x(a); }\n" + + "}" + }, + "" + ); +} + +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=200547 +public void test065() { + this.runConformTest( + new String[] { + "A.java", + "public abstract class A {\n" + + " abstract <T extends Number & Comparable<T>> void m(T x);\n" + + "}\n" + + "class B extends A {\n" + + " @Override <T extends Number & Comparable<T>> void m(T x) {}\n" + + "}" + }, + "" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=214558 +public void test066() { + this.runNegativeTest( + new String[] { + "A.java", + "import java.util.*;\n" + + "public class A {\n" + + " void foo(Collection<Object[]> c) {}\n" + + " void foo(Collection<Object[]> c, Object o) {}\n" + + " public static void main(String[] args) {\n" + + " new B().foo(new ArrayList());\n" + + " new B().foo(new ArrayList(), args[0]);\n" + + " }\n" + + "}\n" + + "class B extends A {\n" + + " void foo(ArrayList a) {}\n" + + " void foo(ArrayList a, Object o) {}\n" + + "}" + }, + "----------\n" + + "1. ERROR in A.java (at line 6)\n" + + " new B().foo(new ArrayList());\n" + + " ^^^\n" + + "The method foo(ArrayList) is ambiguous for the type B\n" + + "----------\n" + + "2. WARNING in A.java (at line 6)\n" + + " new B().foo(new ArrayList());\n" + + " ^^^^^^^^^\n" + + "ArrayList is a raw type. References to generic type ArrayList<E> should be parameterized\n" + + "----------\n" + + "3. ERROR in A.java (at line 7)\n" + + " new B().foo(new ArrayList(), args[0]);\n" + + " ^^^\n" + + "The method foo(ArrayList, Object) is ambiguous for the type B\n" + + "----------\n" + + "4. WARNING in A.java (at line 7)\n" + + " new B().foo(new ArrayList(), args[0]);\n" + + " ^^^^^^^^^\n" + + "ArrayList is a raw type. References to generic type ArrayList<E> should be parameterized\n" + + "----------\n" + + "5. WARNING in A.java (at line 11)\n" + + " void foo(ArrayList a) {}\n" + + " ^^^^^^^^^\n" + + "ArrayList is a raw type. References to generic type ArrayList<E> should be parameterized\n" + + "----------\n" + + "6. WARNING in A.java (at line 12)\n" + + " void foo(ArrayList a, Object o) {}\n" + + " ^^^^^^^^^\n" + + "ArrayList is a raw type. References to generic type ArrayList<E> should be parameterized\n" + + "----------\n" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=214558 - positive case +public void test067() { + this.runConformTest( + new String[] { + "A.java", + "import java.util.*;\n" + + "public class A {\n" + + " void foo(Collection<Object[]> c) {}\n" + + " public static void main(String[] args) {\n" + + " new B().foo(new ArrayList<Object>());\n" + + " }\n" + + "}\n" + + "class B extends A {\n" + + " void foo(ArrayList<Object> a) {System.out.print(1);}\n" + + "}" + }, + "1" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=251279 +public void test068() { + this.runConformTest( + new String[] { + "X.java", + "interface A { X<? extends A> foo(); }\n" + + "interface B extends A { X<? extends B> foo(); }\n" + + "interface C extends B, A {}\n" + + "interface D extends A, B {}\n" + + "public class X<T> {\n" + + " public static void main(String[] args) {\n" + + " C c = null;\n" + + " X<? extends B> c_b = c.foo();\n" + + " D d = null;\n" + + " X<? extends B> d_b = d.foo();\n" + + " }\n" + + "}" + }, + "" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=251279 - variation +public void test069() { + this.runNegativeTest( + new String[] { + "X.java", + "interface A { X<? extends B> foo(); }\n" + + "interface B extends A { X<? extends A> foo(); }\n" + + "interface C extends B, A {}\n" + + "interface D extends A, B {}\n" + + "public class X<T> {\n" + + " void test(C c, D d) {\n" + + " X<? extends B> c_b = c.foo();\n" + + " X<? extends B> d_b = d.foo();\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in X.java (at line 2)\n" + + " interface B extends A { X<? extends A> foo(); }\n" + + " ^^^^^^^^^^^^^^\n" + + "The return type is incompatible with A.foo()\n" + + "----------\n" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=251279 - variation +public void test070() { + this.runNegativeTest( + new String[] { + "X.java", + "interface A { X<? extends A> foo(); }\n" + + "interface B { X<? extends B> foo(); }\n" + + "interface C extends B, A {}\n" + + "interface D extends A, B {}\n" + + "public class X<T> {\n" + + " public static void main(String[] args) {\n" + + " C c = null;\n" + + " X<? extends B> c_b = c.foo();\n" + + " D d = null;\n" + + " X<? extends B> d_b = d.foo();\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in X.java (at line 3)\n" + + " interface C extends B, A {}\n" + + " ^\n" + + "The return types are incompatible for the inherited methods A.foo(), B.foo()\n" + + "----------\n" + + "2. ERROR in X.java (at line 4)\n" + + " interface D extends A, B {}\n" + + " ^\n" + + "The return types are incompatible for the inherited methods B.foo(), A.foo()\n" + + "----------\n" + + "3. ERROR in X.java (at line 8)\n" + + " X<? extends B> c_b = c.foo();\n" + + " ^^^\n" + + "The method foo() is ambiguous for the type C\n" + + "----------\n" + + "4. ERROR in X.java (at line 10)\n" + + " X<? extends B> d_b = d.foo();\n" + + " ^^^\n" + + "The method foo() is ambiguous for the type D\n" + + "----------\n" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=251279 - variation +public void test071() { + this.runConformTest( + new String[] { + "Y.java", + "interface I {\n" + + " Integer a();\n" + + " Float b();\n" + + "}\n" + + "interface J {\n" + + " Integer a();\n" + + " Double c();\n" + + "}\n" + + "abstract class X {\n" + + " public abstract Float b();\n" + + " public Double c() { return null; }\n" + + "}\n" + + "abstract class Y extends X implements I, J {\n" + + " void test() {\n" + + " Integer i = a();\n" + + " Float f = b();\n" + + " Double d = c();\n" + + " }\n" + + "}" + }, + "" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=251279 - variation +public void test072() { + this.runConformTest( + new String[] { + "Y.java", + "interface I {\n" + + " Number a();\n" + + " Number b();\n" + + "}\n" + + "interface J {\n" + + " Integer a();\n" + + " Number c();\n" + + "}\n" + + "abstract class X {\n" + + " public abstract Float b();\n" + + " public Double c() { return null; }\n" + + "}\n" + + "abstract class Y extends X implements I, J {\n" + + " void test() {\n" + + " Integer i = a();\n" + + " Float f = b();\n" + + " Double d = c();\n" + + " }\n" + + "}\n" + + "abstract class Y2 extends X implements J, I {\n" + + " void test() {\n" + + " Integer i = a();\n" + + " Float f = b();\n" + + " Double d = c();\n" + + " }\n" + + "}" + }, + "" // javac reports 4 ambiguous errors, 2 each of a() & b() even tho the return types are sustitutable + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=251279 - variation +public void test073() { + this.runNegativeTest( + new String[] { + "Y.java", + "interface I {\n" + + " int a();\n" + + " int b();\n" + + "}\n" + + "interface J {\n" + + " byte a();\n" + + " int c();\n" + + "}\n" + + "abstract class X {\n" + + " public abstract byte b();\n" + + " public byte c() { return 1; }\n" + + "}\n" + + "abstract class Y extends X implements I, J {\n" + + " void test() {\n" + + " byte a = a();\n" + + " byte b = b();\n" + + " byte c = c();\n" + + " }\n" + + "}\n" + + "abstract class Y2 extends X implements J, I {\n" + + " void test() {\n" + + " byte a = a();\n" + + " byte b = b();\n" + + " byte c = c();\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in Y.java (at line 13)\n" + + " abstract class Y extends X implements I, J {\n" + + " ^\n" + + "The return types are incompatible for the inherited methods J.c(), X.c()\n" + + "----------\n" + + "2. ERROR in Y.java (at line 13)\n" + + " abstract class Y extends X implements I, J {\n" + + " ^\n" + + "The return types are incompatible for the inherited methods I.b(), X.b()\n" + + "----------\n" + + "3. ERROR in Y.java (at line 13)\n" + + " abstract class Y extends X implements I, J {\n" + + " ^\n" + + "The return types are incompatible for the inherited methods J.a(), I.a()\n" + + "----------\n" + + "4. ERROR in Y.java (at line 20)\n" + + " abstract class Y2 extends X implements J, I {\n" + + " ^^\n" + + "The return types are incompatible for the inherited methods J.c(), X.c()\n" + + "----------\n" + + "5. ERROR in Y.java (at line 20)\n" + + " abstract class Y2 extends X implements J, I {\n" + + " ^^\n" + + "The return types are incompatible for the inherited methods I.b(), X.b()\n" + + "----------\n" + + "6. ERROR in Y.java (at line 20)\n" + + " abstract class Y2 extends X implements J, I {\n" + + " ^^\n" + + "The return types are incompatible for the inherited methods I.a(), J.a()\n" + + "----------\n" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=206930 +public void test074() { + this.runNegativeTest( + new String[] { + "Y.java", + "interface I<T> {}\n" + + "class A {\n" + + " void a(I x) {}\n" + + " void b(I<?> x) {}\n" + + " void b(I<?>[] x) {}\n" + + " <U> void c(I<?> x) {}\n" + + "}\n" + + "class B extends A {}\n" + + "class C extends B implements I {\n" + + " void a(C c) {}\n" + + " void b(C c) {}\n" + + " void b(C[] c) {}\n" + + " void c(C c) {}\n" + + "}\n" + + "class D extends C {\n" + + " void test() {\n" + + " a(new C());\n" + + " a(new D());\n" + + " b(new C());\n" + // ambiguous b(I<?>) in A and b(C) in C match + " b(new D());\n" + // ambiguous b(I<?>) in A and b(C) in C match + " b(new C[0]);\n" + // ambiguous b(I<?>[]) in A and b(C[]) in C match + " b(new D[0]);\n" + // ambiguous b(I<?>[]) in A and b(C[]) in C match + " c(new C());\n" + // ambiguous <U>c(I<?>) in A and c(C) in C match + " c(new D());\n" + // ambiguous <U>c(I<?>) in A and c(C) in C match + " }\n" + + "}\n" + + "class A2<T> {\n" + + " void a(I x) {}\n" + + " void b(I<?> x) {}\n" + + " <U> void c(I<?> x) {}\n" + + " void d(I<T> x) {}\n" + + "}\n" + + "class B2 extends A2 {}\n" + + "class C2 extends B2 implements I {\n" + + " void a(C2 c) {}\n" + + " void b(C2 c) {}\n" + + " void c(C2 c) {}\n" + + " void d(C2 c) {}\n" + + "}\n" + + "class D2 extends C2 {\n" + + " void test() {\n" + + " a(new C2());\n" + + " a(new D2());\n" + + " b(new C2());\n" + + " b(new D2());\n" + + " c(new C2());\n" + + " c(new D2());\n" + + " d(new C2());\n" + + " d(new D2());\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. WARNING in Y.java (at line 3)\n" + + " void a(I x) {}\n" + + " ^\n" + + "I is a raw type. References to generic type I<T> should be parameterized\n" + + "----------\n" + + "2. WARNING in Y.java (at line 9)\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" + + "3. ERROR in Y.java (at line 19)\n" + + " b(new C());\n" + + " ^\n" + + "The method b(C) is ambiguous for the type D\n" + + "----------\n" + + "4. ERROR in Y.java (at line 20)\n" + + " b(new D());\n" + + " ^\n" + + "The method b(C) is ambiguous for the type D\n" + + "----------\n" + + "5. ERROR in Y.java (at line 21)\n" + + " b(new C[0]);\n" + + " ^\n" + + "The method b(C[]) is ambiguous for the type D\n" + + "----------\n" + + "6. ERROR in Y.java (at line 22)\n" + + " b(new D[0]);\n" + + " ^\n" + + "The method b(C[]) is ambiguous for the type D\n" + + "----------\n" + + "7. ERROR in Y.java (at line 23)\n" + + " c(new C());\n" + + " ^\n" + + "The method c(C) is ambiguous for the type D\n" + + "----------\n" + + "8. ERROR in Y.java (at line 24)\n" + + " c(new D());\n" + + " ^\n" + + "The method c(C) is ambiguous for the type D\n" + + "----------\n" + + "9. WARNING in Y.java (at line 28)\n" + + " void a(I x) {}\n" + + " ^\n" + + "I is a raw type. References to generic type I<T> should be parameterized\n" + + "----------\n" + + "10. WARNING in Y.java (at line 33)\n" + + " class B2 extends A2 {}\n" + + " ^^\n" + + "A2 is a raw type. References to generic type A2<T> should be parameterized\n" + + "----------\n" + + "11. WARNING in Y.java (at line 34)\n" + + " class C2 extends B2 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=266421 +public void test075() { + this.runNegativeTest( + new String[] { + "C.java", + "abstract class A<T extends Comparable> {\n" + + " abstract int x(T val);\n" + + "}\n" + + "class B<T extends Comparable> extends A<T> {\n" + + " @Override int x(T val) { return 0; }\n" + + "}\n" + + "class C extends B<Double> {\n" + + " int test(Double val) { return x(val); }\n" + + "}" + }, + "----------\n" + + "1. WARNING in C.java (at line 1)\n" + + " abstract class A<T extends Comparable> {\n" + + " ^^^^^^^^^^\n" + + "Comparable is a raw type. References to generic type Comparable<T> should be parameterized\n" + + "----------\n" + + "2. WARNING in C.java (at line 4)\n" + + " class B<T extends Comparable> extends A<T> {\n" + + " ^^^^^^^^^^\n" + + "Comparable is a raw type. References to generic type Comparable<T> should be parameterized\n" + + "----------\n" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=268837 +public void test076() { + this.runNegativeTest( + new String[] { + "X.java", + "interface I<E> {\n" + + " I<String> a();\n" + + " I<String> b();\n" + + " <T1> I<T1> c();\n" + + "}\n" + + "interface J<E> extends I<E> {\n" + + " J<String> a();\n" + + " <U> J<String> b();\n" + + " <T2> J<T2> c();\n" + + "}\n" + + "class X {\n" + + " void a(J<Integer> ints) {\n" + + " ints.a();\n" + + " J<String> a = ints.a();\n" + + " J<Integer> b = ints.a();\n" + // incompatible types + " J<Object> c = ints.a();\n" + // incompatible types + " J d = ints.a();\n" + + " I<String> e = ints.a();\n" + + " I<Integer> f = ints.a();\n" + // incompatible types + " I<Object> g = ints.a();\n" + // incompatible types + " I h = ints.a();\n" + + " }\n" + + " void b(J<Integer> ints) {\n" + + " ints.b();\n" + // ambiguous + " J<String> a = ints.b();\n" + // ambiguous + " J<Integer> b = ints.b();\n" + // ambiguous + " J<Object> c = ints.b();\n" + // ambiguous + " J d = ints.b();\n" + // ambiguous + " I<String> e = ints.b();\n" + // ambiguous + " I<Integer> f = ints.b();\n" + // ambiguous + " I<Object> g = ints.b();\n" + // ambiguous + " I h = ints.b();\n" + // ambiguous + " }\n" + + " void c(J<Integer> ints) {\n" + + " ints.c();\n" + + " J<String> a = ints.c();\n" + + " J<Integer> b = ints.c();\n" + + " J<Object> c = ints.c();\n" + + " J d = ints.c();\n" + + " I<String> e = ints.c();\n" + + " I<Integer> f = ints.c();\n" + + " I<Object> g = ints.c();\n" + + " I h = ints.c();\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in X.java (at line 15)\n" + + " J<Integer> b = ints.a();\n" + + " ^^^^^^^^\n" + + "Type mismatch: cannot convert from J<String> to J<Integer>\n" + + "----------\n" + + "2. ERROR in X.java (at line 16)\n" + + " J<Object> c = ints.a();\n" + + " ^^^^^^^^\n" + + "Type mismatch: cannot convert from J<String> to J<Object>\n" + + "----------\n" + + "3. WARNING in X.java (at line 17)\n" + + " J d = ints.a();\n" + + " ^\n" + + "J is a raw type. References to generic type J<E> should be parameterized\n" + + "----------\n" + + "4. ERROR in X.java (at line 19)\n" + + " I<Integer> f = ints.a();\n" + + " ^^^^^^^^\n" + + "Type mismatch: cannot convert from J<String> to I<Integer>\n" + + "----------\n" + + "5. ERROR in X.java (at line 20)\n" + + " I<Object> g = ints.a();\n" + + " ^^^^^^^^\n" + + "Type mismatch: cannot convert from J<String> to I<Object>\n" + + "----------\n" + + "6. WARNING in X.java (at line 21)\n" + + " I h = ints.a();\n" + + " ^\n" + + "I is a raw type. References to generic type I<E> should be parameterized\n" + + "----------\n" + + "7. ERROR in X.java (at line 24)\n" + + " ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "8. ERROR in X.java (at line 25)\n" + + " J<String> a = ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "9. ERROR in X.java (at line 26)\n" + + " J<Integer> b = ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "10. ERROR in X.java (at line 27)\n" + + " J<Object> c = ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "11. WARNING in X.java (at line 28)\n" + + " J d = ints.b();\n" + + " ^\n" + + "J is a raw type. References to generic type J<E> should be parameterized\n" + + "----------\n" + + "12. ERROR in X.java (at line 28)\n" + + " J d = ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "13. ERROR in X.java (at line 29)\n" + + " I<String> e = ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "14. ERROR in X.java (at line 30)\n" + + " I<Integer> f = ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "15. ERROR in X.java (at line 31)\n" + + " I<Object> g = ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "16. WARNING in X.java (at line 32)\n" + + " I h = ints.b();\n" + + " ^\n" + + "I is a raw type. References to generic type I<E> should be parameterized\n" + + "----------\n" + + "17. ERROR in X.java (at line 32)\n" + + " I h = ints.b();\n" + + " ^\n" + + "The method b() is ambiguous for the type J<Integer>\n" + + "----------\n" + + "18. WARNING in X.java (at line 39)\n" + + " J d = ints.c();\n" + + " ^\n" + + "J is a raw type. References to generic type J<E> should be parameterized\n" + + "----------\n" + + "19. WARNING in X.java (at line 43)\n" + + " I h = ints.c();\n" + + " ^\n" + + "I is a raw type. References to generic type I<E> should be parameterized\n" + + "----------\n" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=270194 +public void test077() { + this.runConformTest( + new String[] { + "X.java", + "abstract class X implements I {\n" + + " public <A extends J<A, D>, D extends J<A, D>> A method(A arg) { return null; }\n" + + " void test(Y<String> c) { method(c); }\n" + + "}\n" + + "interface I {\n" + + " <A extends J<A,D>, D extends J<A,D>> A method(A arg);\n" + + "}\n" + + "interface J<A extends J<A,D>, D extends J<A,D>> {}\n" + + "class Y<E> implements J<Y<E>, Y<E>> {}" + }, + "" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=287592 +public void test078() { + this.runNegativeTest( + new String[] { + "X.java", + "class X {\n" + + " class Field<T> { T value; }\n" + + " <T> void a(T value) {}\n" + + " <T> void a(Field<T> field) {}\n" + + " <T extends Number> void b(T value) {}\n" + + " <T> void b(Field<T> field) {}\n" + + " void c(String value) {}\n" + + " void c(Field<String> field) {}\n" + + " void test(X x) {\n" + + " x.a(null);\n" + + " x.<String>a(null);\n" + + " x.b(null);\n" + + " x.<Integer>b(null);\n" + + " x.c(null);\n" + + " }\n" + + "}" + }, + "----------\n" + + "1. ERROR in X.java (at line 12)\n" + + " x.b(null);\n" + + " ^\n" + + "The method b(Number) is ambiguous for the type X\n" + + "----------\n" + + "2. ERROR in X.java (at line 13)\n" + + " x.<Integer>b(null);\n" + + " ^\n" + + "The method b(Integer) is ambiguous for the type X\n" + + "----------\n" + + "3. ERROR in X.java (at line 14)\n" + + " x.c(null);\n" + + " ^\n" + + "The method c(String) is ambiguous for the type X\n" + + "----------\n" + ); +} + +//https://bugs.eclipse.org/bugs/show_bug.cgi?id=292350 +public void test079() { + this.runConformTest( + new String[] { + "X.java", + "interface I<T> {}\n" + + "class A {}\n" + + "class B extends A {}\n" + + "interface One {\n" + + " I<B> x() throws IllegalAccessError;\n" + + " <T extends A> I<T> y() throws IllegalAccessError;\n" + + "}\n" + + "interface Two extends One {\n" + + " <T extends A> I<T> x() throws IllegalAccessError;\n" + + " I<B> y() throws IllegalAccessError;\n" + + "}\n" + + "class X {\n" + + " void x(Two t) { t.x(); }\n" + + " void y(Two t) { t.y(); }\n" + + "}" + }, + "" + ); +} +// https://bugs.eclipse.org/bugs/show_bug.cgi?id=293384 +public void test080() { + this.runConformTest( + new String[] { + "X.java", + "public class X<Tout extends Object> {\n" + + " static public abstract class BaseA {};\n" + + " static public abstract class BaseB extends BaseA {};\n" + + " static public class Real extends BaseB {};\n" + + " static BaseA ask(String prompt) {\n" + + " Real impl = new Real();\n" + + " return (BaseA) ask(prompt, impl);\n" + + " }\n" + + " static BaseA ask(String prompt, Real impl) {\n" + + " return null;\n" + + " }\n" + + " static <T extends BaseA> T ask(String prompt, T impl) {\n" + + " return null;\n" + + " }\n" + + " static public void main(String[] args) {\n" + + " System.out.println(\"SUCCESS\");\n" + + " }\n" + + "}\n" + }, + "SUCCESS"); +} +} |