| /******************************************************************************* |
| * Copyright (c) 2011, 2016 IBM Corporation. |
| * 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 |
| * Stephan Herrmann - Contribution for |
| * Bug 400874 - [1.8][compiler] Inference infrastructure should evolve to meet JLS8 18.x (Part G of JSR335 spec) |
| * Bug 424205 - [1.8] Cannot infer type for diamond type with lambda on method invocation |
| * Bug 429203 - [1.8][compiler] NPE in AllocationExpression.binding |
| * Bug 456508 - Unexpected RHS PolyTypeBinding for: <code-snippet> |
| * Bug 462083 - [1.8][inference] Java 8 generic return type mismatch with interface involving type parameter. |
| *******************************************************************************/ |
| package org.eclipse.jdt.core.tests.compiler.regression; |
| |
| import java.util.Map; |
| |
| import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants; |
| import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; |
| |
| import junit.framework.Test; |
| |
| @SuppressWarnings({ "unchecked", "rawtypes" }) |
| public class GenericsRegressionTest_1_7 extends AbstractRegressionTest { |
| |
| static { |
| // TESTS_NAMES = new String[] { "testBug456508" }; |
| // TESTS_NUMBERS = new int[] { 40, 41, 43, 45, 63, 64 }; |
| // TESTS_RANGE = new int[] { 11, -1 }; |
| } |
| public GenericsRegressionTest_1_7(String name) { |
| super(name); |
| } |
| public static Test suite() { |
| return buildMinimalComplianceTestSuite(testClass(), F_1_7); |
| } |
| public void test001() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>();\n" + |
| " x.testFunction(\"SUCCESS\");\n" + |
| " }\n" + |
| " public void testFunction(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS"); |
| } |
| public void test001a() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>();\n" + |
| " x.testFunction(1);\n" + |
| " }\n" + |
| " public void testFunction(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 4)\n" + |
| " x.testFunction(1);\n" + |
| " ^^^^^^^^^^^^\n" + |
| "The method testFunction(String) in the type X<String> is not applicable for the arguments (int)\n" + |
| "----------\n"); |
| } |
| public void test001b() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " public static void main(String[] args) {\n" + |
| " java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" + |
| " x.add(\"\");\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS"); |
| } |
| // fields |
| public void test001b_1() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " static java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" + |
| " public static void main(String[] args) {\n" + |
| " X.x.add(\"\");\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS"); |
| } |
| public void test001c() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " public static void main(String[] args) {\n" + |
| " java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" + |
| " x.add(1);\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 4)\n" + |
| " x.add(1);\n" + |
| " ^^^\n" + |
| "The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)\n" + |
| "----------\n"); |
| } |
| // fields |
| public void test001c_1() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " static java.util.ArrayList<String> x = new java.util.ArrayList<>();\n" + |
| " public static void main(String[] args) {\n" + |
| " X.x.add(1);\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 4)\n" + |
| " X.x.add(1);\n" + |
| " ^^^\n" + |
| "The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)\n" + |
| "----------\n"); |
| } |
| public void test001d() { |
| if (this.complianceLevel < ClassFileConstants.JDK1_8) { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.ArrayList;\n" + |
| "public class X<T> {" + |
| " public void ab(ArrayList<String> al){\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>();\n" + |
| " x.ab(new ArrayList<>());\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 7)\n" + |
| " x.ab(new ArrayList<>());\n" + |
| " ^^\n" + |
| "The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Object>)\n" + |
| "----------\n"); |
| } else { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "import java.util.ArrayList;\n" + |
| "public class X<T> {" + |
| " public void ab(ArrayList<String> al){\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>();\n" + |
| " x.ab(new ArrayList<>());\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS"); |
| } |
| } |
| public void test001e() { |
| if (this.complianceLevel < ClassFileConstants.JDK1_8) { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.ArrayList;\n" + |
| "public class X<T> {" + |
| " public void ab(ArrayList<T> al){\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>();\n" + |
| " x.ab(new ArrayList<>());\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 7)\n" + |
| " x.ab(new ArrayList<>());\n" + |
| " ^^\n" + |
| "The method ab(ArrayList<String>) in the type X<String> is not applicable for the arguments (ArrayList<Object>)\n" + |
| "----------\n"); |
| } else { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "import java.util.ArrayList;\n" + |
| "public class X<T> {" + |
| " public void ab(ArrayList<T> al){\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>();\n" + |
| " x.ab(new ArrayList<>());\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS"); |
| } |
| } |
| public void test001f() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<T>{\n" + |
| " void methodx(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.X2<String> x = new X<>().new X2<>();\n" + |
| " x.methodx(\"SUCCESS\");\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 2)\n" + |
| " class X2<T>{\n" + |
| " ^\n" + |
| "The type parameter T is hiding the type T\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 8)\n" + |
| " X<String>.X2<String> x = new X<>().new X2<>();\n" + |
| " ^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.X2<String> to X<String>.X2<String>\n" |
| : |
| "Cannot infer type arguments for X2<>\n" |
| ) + |
| "----------\n"); |
| } |
| // fields |
| public void test001f_1() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<T>{\n" + |
| " void methodx(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| " }\n" + |
| " X<String>.X2<String> x;\n" + |
| " public static void main(String[] args) {\n" + |
| " X test = new X();\n" + |
| " test.x = new X<>().new X2<>();\n" + |
| " test.x.methodx(\"SUCCESS\");\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS"); |
| } |
| public void test001g() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<K>{\n" + |
| " void methodx(T param, K param2){\n" + |
| " System.out.println(param);\n" + |
| " System.out.println(param2);\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.X2<Integer> x = new X<>().new X2<>();\n" + |
| " x.methodx(\"SUCCESS\",1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 9)\n" + |
| " X<String>.X2<Integer> x = new X<>().new X2<>();\n" + |
| " ^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.X2<Integer> to X<String>.X2<Integer>\n" |
| : |
| "Cannot infer type arguments for X2<>\n" |
| ) + |
| "----------\n"); |
| } |
| public void test001g_1() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<K>{\n" + |
| " void methodx(T param, K param2){\n" + |
| " System.out.println(param);\n" + |
| " System.out.println(param2);\n" + |
| " }\n" + |
| " }\n" + |
| " X<String>.X2<Integer> x;\n" + |
| " public static void main(String[] args) {\n" + |
| " X test = new X();" + |
| " test.x = new X<>().new X2<>();\n" + |
| " test.x.methodx(\"SUCCESS\",1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS\n1"); |
| } |
| public void test001h() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<T>{\n" + |
| " void methodx(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.X2<String> x = new X<>().new X2<>();\n" + |
| " x.methodx(1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 2)\n" + |
| " class X2<T>{\n" + |
| " ^\n" + |
| "The type parameter T is hiding the type T\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 8)\n" + |
| " X<String>.X2<String> x = new X<>().new X2<>();\n" + |
| " ^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.X2<String> to X<String>.X2<String>\n" |
| : |
| "Cannot infer type arguments for X2<>\n" |
| ) + |
| "----------\n" + |
| "3. ERROR in X.java (at line 9)\n" + |
| " x.methodx(1);\n" + |
| " ^^^^^^^\n" + |
| "The method methodx(String) in the type X<String>.X2<String> is not applicable for the arguments (int)\n" + |
| "----------\n"); |
| } |
| public void test001h_1() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<T>{\n" + |
| " void methodx(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| " }\n" + |
| " X<String>.X2<String> x;\n" + |
| " public static void main(String[] args) {\n" + |
| " X test = new X();\n" + |
| " test.x = new X<>().new X2<>();\n" + |
| " test.x.methodx(1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 2)\n" + |
| " class X2<T>{\n" + |
| " ^\n" + |
| "The type parameter T is hiding the type T\n" + |
| "----------\n" + |
| "2. WARNING in X.java (at line 9)\n" + |
| " X test = new X();\n" + |
| " ^\n" + |
| "X is a raw type. References to generic type X<T> should be parameterized\n" + |
| "----------\n" + |
| "3. WARNING in X.java (at line 9)\n" + |
| " X test = new X();\n" + |
| " ^\n" + |
| "X is a raw type. References to generic type X<T> should be parameterized\n" + |
| "----------\n" + |
| "4. WARNING in X.java (at line 10)\n" + |
| " test.x = new X<>().new X2<>();\n" + |
| " ^\n" + |
| "Type safety: The field x from the raw type X is assigned a value of type X<Object>.X2<Object>. References to generic type X<T> should be parameterized\n" + |
| "----------\n" + |
| "5. WARNING in X.java (at line 11)\n" + |
| " test.x.methodx(1);\n" + |
| " ^^^^^^^^^^^^^^^^^\n" + |
| "Type safety: The method methodx(Object) belongs to the raw type X.X2. References to generic type X<T>.X2<T> should be parameterized\n" + |
| "----------\n"); |
| } |
| public void test001h_2() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<T>{\n" + |
| " void methodx(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| " }\n" + |
| " X<String>.X2<String> x;\n" + |
| " public static void main(String[] args) {\n" + |
| " X test = new X();\n" + |
| " test.x = new X<>().new X2<>();\n" + |
| " test.x.methodx(1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "1"); |
| } |
| public void test001i() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<K>{\n" + |
| " class X22<I>{\n" + |
| " void methodx(T param, K param2, I param3){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> test = new X<>();" + |
| " X<String>.X2<Integer>.X22<X<String>> x = new X<>().new X2<>().new X22<>();\n" + |
| " x.methodx(\"SUCCESS\", 1, test);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 10)\n" + |
| " X<String> test = new X<>(); X<String>.X2<Integer>.X22<X<String>> x = new X<>().new X2<>().new X22<>();\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.X2<Object>.X22<X<String>> to X<String>.X2<Integer>.X22<X<String>>\n" |
| : |
| "Cannot infer type arguments for X22<>\n" |
| ) + |
| "----------\n"); |
| } |
| public void test002() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " public static void main(String[] args) {\n" + |
| " X x = new X<>();\n" + |
| " x.testFunction(\"SUCCESS\");\n" + |
| " }\n" + |
| " public void testFunction(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 3)\n" + |
| " X x = new X<>();\n" + |
| " ^\n" + |
| "X is a raw type. References to generic type X<T> should be parameterized\n" + |
| "----------\n" + |
| "2. WARNING in X.java (at line 4)\n" + |
| " x.testFunction(\"SUCCESS\");\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Type safety: The method testFunction(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" + |
| "----------\n"); |
| } |
| public void test003() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " public static void main(String[] args) {\n" + |
| " new X<>().testFunction(\"SUCCESS\");\n" + |
| " }\n" + |
| " public void testFunction(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS"); |
| } |
| |
| public void test004b() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<U> {\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " new X<>().new X2<>(){\n" + |
| " void newMethod(){\n" + |
| " }\n" + |
| " };\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " new X<>().new X2<>(){\n" + |
| " ^^\n" + |
| "\'<>\' cannot be used with anonymous classes\n" + |
| "----------\n"); |
| } |
| public void test004c() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class X2<U> {\n" + |
| " U f1;" + |
| " public void setF(U a){\n" + |
| " this.f1 = a;" + |
| " System.out.println(this.f1);\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " new X<>().new X2<Integer>(){\n" + |
| " void newMethod(){\n" + |
| " }\n" + |
| " }.setF(1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "1"); |
| } |
| |
| public void test006() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "class X1<T> {\n" + |
| " int abc = 1;\n" + |
| " public void testFunction(T param){\n" + |
| " System.out.println(param + \"X1\");\n" + |
| " }\n" + |
| "}\n" + |
| "public class X<T> extends X1<T> {\n" + |
| " public static void main(String[] args) {\n" + |
| " X1<String> x = new X<>();\n" + |
| " x.testFunction(\"SUCCESS\");\n" + |
| " }\n" + |
| " public void testFunction(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS"); |
| } |
| // shows the difference between using <> and the raw type - different semantics |
| public void test007() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " T field1;" + |
| " public X(T param){\n" + |
| " field1 = param;\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X.testFunction(new X<>(\"hello\").getField());\n" + // prints 1 |
| " X.testFunction(new X(\"hello\").getField());\n" + //prints 2 |
| " }\n" + |
| " public static void testFunction(String param){\n" + |
| " System.out.println(1);\n" + |
| " }\n" + |
| " public static void testFunction(Object param){\n" + |
| " System.out.println(2);\n" + |
| " }\n" + |
| " public T getField(){\n" + |
| " return field1;" + |
| " }\n" + |
| "}", |
| }, |
| "1\n" + |
| "2"); |
| } |
| public void test007a() { |
| if (this.complianceLevel < ClassFileConstants.JDK1_8) { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " public X(){\n" + |
| " }\n" + |
| " public X(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| " public static void testFunction(X<String> param){\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X.testFunction(new X<>());\n" + |
| " X.testFunction(new X(\"hello\"));\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 11)\n" + |
| " X.testFunction(new X<>());\n" + |
| " ^^^^^^^^^^^^\n" + |
| "The method testFunction(X<String>) in the type X is not applicable for the arguments (X<Object>)\n" + |
| "----------\n" + |
| "2. WARNING in X.java (at line 12)\n" + |
| " X.testFunction(new X(\"hello\"));\n" + |
| " ^^^^^^^^^^^^^^\n" + |
| "Type safety: The constructor X(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" + |
| "----------\n" + |
| "3. WARNING in X.java (at line 12)\n" + |
| " X.testFunction(new X(\"hello\"));\n" + |
| " ^^^^^^^^^^^^^^\n" + |
| "Type safety: The expression of type X needs unchecked conversion to conform to X<String>\n" + |
| "----------\n" + |
| "4. WARNING in X.java (at line 12)\n" + |
| " X.testFunction(new X(\"hello\"));\n" + |
| " ^\n" + |
| "X is a raw type. References to generic type X<T> should be parameterized\n" + |
| "----------\n"); |
| } else { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " public X(){\n" + |
| " }\n" + |
| " public X(T param){\n" + |
| " System.out.println(param);\n" + |
| " }\n" + |
| " public static void testFunction(X<String> param){\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X.testFunction(new X<>());\n" + |
| " X.testFunction(new X(\"hello\"));\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS\n" + |
| "hello\n" + |
| "SUCCESS"); |
| } |
| } |
| //shows the difference between using <> and the raw type - different semantics |
| public void test008() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " T field1;\n" + |
| " public X(T param){\n" + |
| " field1 = param;\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<?> x1 = new X(1).get(\"\");\n" + // ok - passing String where Object is expected |
| " X<?> x2 = new X<>(1).get(\"\");\n" + // bad - passing String where Integer is expected |
| " }\n" + |
| " public X<T> get(T t){\n" + |
| " return this;" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 7)\n" + |
| " X<?> x1 = new X(1).get(\"\");\n" + |
| " ^^^^^^^^\n" + |
| "Type safety: The constructor X(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" + |
| "----------\n" + |
| "2. WARNING in X.java (at line 7)\n" + |
| " X<?> x1 = new X(1).get(\"\");\n" + |
| " ^^^^^^^^^^^^^^^^\n" + |
| "Type safety: The method get(Object) belongs to the raw type X. References to generic type X<T> should be parameterized\n" + |
| "----------\n" + |
| "3. WARNING in X.java (at line 7)\n" + |
| " X<?> x1 = new X(1).get(\"\");\n" + |
| " ^\n" + |
| "X is a raw type. References to generic type X<T> should be parameterized\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 8)\n" + |
| " X<?> x2 = new X<>(1).get(\"\");\n" + |
| " ^^^\n" + |
| "The method get(Integer) in the type X<Integer> is not applicable for the arguments (String)\n" + |
| "----------\n"); |
| } |
| |
| public void test0014() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<J,K> {\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String,Integer> x = new X<>();\n" + |
| " x.testFunction(\"SUCCESS\", 123);\n" + |
| " }\n" + |
| " public void testFunction(J param, K param2){\n" + |
| " System.out.println(param);\n" + |
| " System.out.println(param2);\n" + |
| " }\n" + |
| "}", |
| }, |
| "SUCCESS\n" + |
| "123"); |
| } |
| public void test0014a() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<J,K> {\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String,Integer> x = new X<>();\n" + |
| " x.testFunction(123, \"SUCCESS\");\n" + |
| " }\n" + |
| " public void testFunction(J param, K param2){\n" + |
| " System.out.println(param);\n" + |
| " System.out.println(param2);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 4)\n" + |
| " x.testFunction(123, \"SUCCESS\");\n" + |
| " ^^^^^^^^^^^^\n" + |
| "The method testFunction(String, Integer) in the type X<String,Integer> is not applicable for the arguments (int, String)\n" + |
| "----------\n"); |
| } |
| public void test0015() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " X (T t) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>();\n" + |
| " X<String> x2 = new X<>(\"\");\n" + |
| " }\n" + |
| "}", |
| }, |
| "const.1\nconst.2"); |
| } |
| // To verify that <> cannot be used with explicit type arguments to generic constructor. |
| public void test0016() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " <E> X(){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " <K,J> X (Integer i) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new <String>X<>();\n" + |
| " X<String> x2 = new <String, Integer>X<>(1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 9)\n" + |
| " X<String> x = new <String>X<>();\n" + |
| " ^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 10)\n" + |
| " X<String> x2 = new <String, Integer>X<>(1);\n" + |
| " ^^^^^^^^^^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n"); |
| } |
| public void test0016a() { |
| this.runConformTest( // javac fails to compile this, looks buggy |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " <E> X(){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " <K,J> X (Integer i) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>();\n" + |
| " X<String> x2 = new X<>(1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "const.1\nconst.2"); |
| } |
| // To verify that <> cannot be used with explicit type arguments to a generic constructor. |
| public void test0016b() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X<String> x;\n" + |
| " X<String> x2;\n" + |
| " <E> X(){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " <K,J> X (Integer i) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Integer> test = new <String>X<>();\n" + |
| " test.x = new <String>X<>();\n" + |
| " test.x2 = new <String, Integer>X<>(1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 11)\n" + |
| " X<Integer> test = new <String>X<>();\n" + |
| " ^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 12)\n" + |
| " test.x = new <String>X<>();\n" + |
| " ^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 13)\n" + |
| " test.x2 = new <String, Integer>X<>(1);\n" + |
| " ^^^^^^^^^^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n"); |
| } |
| //To verify that a parameterized invocation of a generic constructor works even if <> is used |
| //to elide class type parameters. This test handles fields |
| public void test0016c() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X<String> x;\n" + |
| " X<String> x2;\n" + |
| " <E> X(){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " <K,J> X (Integer i) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Integer> test = new X<>();\n" + |
| " test.x = new X<>();\n" + |
| " test.x2 = new X<>(1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "const.1\nconst.1\nconst.2"); |
| } |
| // To verify that <> cannot be used with explicit type arguments to generic constructor. |
| public void test0017() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(int i){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " <K,J> X (Integer i) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>(1);\n" + |
| " X<String> x2 = new <String, Integer>X<>(1);\n" + |
| " Integer i = 1;\n" + |
| " X<String> x3 = new <String, Integer>X<>(i);\n" + |
| " }\n" + |
| "}", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 10)\n" + |
| " X<String> x2 = new <String, Integer>X<>(1);\n" + |
| " ^^^^^^^^^^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 12)\n" + |
| " X<String> x3 = new <String, Integer>X<>(i);\n" + |
| " ^^^^^^^^^^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n" |
| ); |
| } |
| // To verify that a parameterized invocation of a non-generic constructor works even if <> is used |
| // to elide class type parameters. |
| public void test0017a() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(int i){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " <K,J> X (Integer i) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new X<>(1);\n" + |
| " X<String> x2 = new X<>(1);\n" + |
| " Integer i = 1;\n" + |
| " X<String> x3 = new X<>(i);\n" + |
| " }\n" + |
| "}", |
| }, |
| "const.1\nconst.1\nconst.2"); |
| } |
| // To verify that the correct constructor is found by parameter substitution in the diamond case |
| public void test0018() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " X (T t, Integer i) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X x = new X<>(\"\");\n" + |
| " X x2 = new X<>(\"\",1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "const.1\nconst.2"); |
| } |
| // To verify that the correct constructor is found by parameter substitution |
| // in the diamond case -- fields |
| public void test0018b() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X f1;\n" + |
| " X f2;\n" + |
| " X(T t){\n" + |
| " System.out.println(\"const.1\");\n" + |
| " }\n" + |
| " X (T t, Integer i) {\n" + |
| " System.out.println(\"const.2\");\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X x = new X<>(\"\");\n" + |
| " x.f1 = new X<>(\"\");\n" + |
| " x.f2 = new X<>(\"\",1);\n" + |
| " }\n" + |
| "}", |
| }, |
| "const.1\nconst.1\nconst.2"); |
| } |
| public void test0019() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| " String s = new String<>(\"junk\");\n" + |
| "}\n", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 2)\n" + |
| " String s = new String<>(\"junk\");\n" + |
| " ^^^^^^\n" + |
| "The type String is not generic; it cannot be parameterized with arguments <>\n" + |
| "----------\n"); |
| } |
| // check inference at method argument position. |
| public void test0020() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " Zork z;\n" + |
| " public X(T t) {}\n" + |
| " int f(X<String> p) {return 0;}\n" + |
| " int x = f(new X<>(\"\"));\n" + |
| "}\n", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 2)\n" + |
| " Zork z;\n" + |
| " ^^^^\n" + |
| "Zork cannot be resolved to a type\n" + |
| "----------\n"); |
| } |
| //check inference at method argument position. |
| public void test0021() { |
| if (this.complianceLevel < ClassFileConstants.JDK1_8) { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.List;\n" + |
| "import java.util.ArrayList;\n" + |
| "class X<T> {\n" + |
| " public X(T t) {}\n" + |
| " int f(List<String> p) {return 0;}\n" + |
| " int x = f(new ArrayList<>());\n" + |
| "}\n", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 6)\n" + |
| " int x = f(new ArrayList<>());\n" + |
| " ^\n" + |
| "The method f(List<String>) in the type X<T> is not applicable for the arguments (ArrayList<Object>)\n" + |
| "----------\n"); |
| } else { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.List;\n" + |
| "import java.util.ArrayList;\n" + |
| "class X<T> {\n" + |
| " public X(T t) {}\n" + |
| " int f(List<String> p) {return 0;}\n" + |
| " int x = f(new ArrayList<>());\n" + |
| "}\n", |
| }, |
| ""); |
| } |
| } |
| public void test0022() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "import java.util.HashMap;\n" + |
| "import java.util.Map;\n" + |
| "\n" + |
| "class StringKeyHashMap<V> extends HashMap<String, V> { \n" + |
| "}\n" + |
| "\n" + |
| "class IntegerValueHashMap<K> extends HashMap<K, Integer> { \n" + |
| "}\n" + |
| "\n" + |
| "public class X {\n" + |
| " Map<String, Integer> m1 = new StringKeyHashMap<>();\n" + |
| " Map<String, Integer> m2 = new IntegerValueHashMap<>();\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| public void test0023() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.HashMap;\n" + |
| "import java.util.Map;\n" + |
| "\n" + |
| "class StringKeyHashMap<V> extends HashMap<String, V> { \n" + |
| "}\n" + |
| "\n" + |
| "class IntegerValueHashMap<K> extends HashMap<K, Integer> { \n" + |
| "}\n" + |
| "\n" + |
| "public class X {\n" + |
| " Map<String, Integer> m1 = new StringKeyHashMap<>(10);\n" + |
| " Map<String, Integer> m2 = new IntegerValueHashMap<>();\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 4)\n" + |
| " class StringKeyHashMap<V> extends HashMap<String, V> { \n" + |
| " ^^^^^^^^^^^^^^^^\n" + |
| "The serializable class StringKeyHashMap does not declare a static final serialVersionUID field of type long\n" + |
| "----------\n" + |
| "2. WARNING in X.java (at line 7)\n" + |
| " class IntegerValueHashMap<K> extends HashMap<K, Integer> { \n" + |
| " ^^^^^^^^^^^^^^^^^^^\n" + |
| "The serializable class IntegerValueHashMap does not declare a static final serialVersionUID field of type long\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 11)\n" + |
| " Map<String, Integer> m1 = new StringKeyHashMap<>(10);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for StringKeyHashMap<>\n" + |
| "----------\n"); |
| } |
| // check inference at return expression. |
| public void test0024() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.List;\n" + |
| "import java.util.ArrayList;\n" + |
| "class X<T> {\n" + |
| " public X() {}\n" + |
| " X<String> f(List<String> p) {return new X<>();}\n" + |
| "}\n", |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 2)\n" + |
| " import java.util.ArrayList;\n" + |
| " ^^^^^^^^^^^^^^^^^^^\n" + |
| "The import java.util.ArrayList is never used\n" + |
| "----------\n"); |
| } |
| // check inference at cast expression. |
| public void test0025() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.List;\n" + |
| "import java.util.ArrayList;\n" + |
| "class X<T> {\n" + |
| " public X() {}\n" + |
| " void f(List<String> p) { Object o = (X<String>) new X<>();}\n" + |
| "}\n", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " void f(List<String> p) { Object o = (X<String>) new X<>();}\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot cast from X<Object> to X<String>\n" + |
| "----------\n"); |
| } |
| // Test various scenarios. |
| public void test0026() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.List;\n" + |
| "import java.util.ArrayList;\n" + |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X(String s) {}\n" + |
| " X(List<?> l) {}\n" + |
| " X<T> idem() { return this; }\n" + |
| " X<Number> x = new X<>(1);\n" + |
| " X<Integer> x2 = new X<>(1);\n" + |
| " List<?> list = new ArrayList<>();\n" + |
| " X<?> x3 = new X<>(1);\n" + |
| " X<Object> x4 = new X<>(1).idem();\n" + |
| " X<Object> x5 = new X<>(1);\n" + |
| " int m(X<String> xs) { return 0; }\n" + |
| " int i = m(new X<>(\"\"));\n" + |
| " X<?> x6 = new X<>(list);\n" + |
| "}\n" |
| }, |
| this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "----------\n" + |
| "1. ERROR in X.java (at line 8)\n" + |
| " X<Number> x = new X<>(1);\n" + |
| " ^^^^^^^^^^\n" + |
| "Type mismatch: cannot convert from X<Integer> to X<Number>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 12)\n" + |
| " X<Object> x4 = new X<>(1).idem();\n" + |
| " ^^^^^^^^^^^^^^^^^\n" + |
| "Type mismatch: cannot convert from X<Integer> to X<Object>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 13)\n" + |
| " X<Object> x5 = new X<>(1);\n" + |
| " ^^^^^^^^^^\n" + |
| "Type mismatch: cannot convert from X<Integer> to X<Object>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 15)\n" + |
| " int i = m(new X<>(\"\"));\n" + |
| " ^\n" + |
| "The method m(X<String>) in the type X<T> is not applicable for the arguments (X<Object>)\n" + |
| "----------\n" : |
| "----------\n" + |
| "1. ERROR in X.java (at line 12)\n" + |
| " X<Object> x4 = new X<>(1).idem();\n" + |
| " ^^^^^^^^^^^^^^^^^\n" + |
| "Type mismatch: cannot convert from X<Integer> to X<Object>\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=344655 |
| public void test0027() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class Y<U> {\n" + |
| " <K,J> Y (Integer i) {\n" + |
| " }\n" + |
| " }\n" + |
| "\n" + |
| " <K,J> X (Integer i) {\n" + |
| " }\n" + |
| "\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String> x = new <String, Integer> X<>(1);\n" + |
| " X<String> x2 = x.new <String, Integer> Y<>(1);\n" + |
| " }\n" + |
| "}\n", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 11)\n" + |
| " X<String> x = new <String, Integer> X<>(1);\n" + |
| " ^^^^^^^^^^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 12)\n" + |
| " X<String> x2 = x.new <String, Integer> Y<>(1);\n" + |
| " ^^^^^^^^^^^^^^^\n" + |
| "Explicit type arguments cannot be used with \'<>\' in an allocation expression\n" + |
| "----------\n" |
| ); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345239 |
| public void test0028() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X<String> x = new X<> () {}\n;" + |
| " class Y<U> {\n" + |
| " }\n" + |
| " X<String>.Y<String> y = x.new Y<>() {};\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 2)\n" + |
| " X<String> x = new X<> () {}\n" + |
| " ^\n" + |
| "\'<>\' cannot be used with anonymous classes\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 5)\n" + |
| " X<String>.Y<String> y = x.new Y<>() {};\n" + |
| " ^\n" + |
| "\'<>\' cannot be used with anonymous classes\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345359 |
| public void test0029() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X<String> f2 = new X<>(new Y()); \n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 3)\n" + |
| " X<String> f2 = new X<>(new Y()); \n" + |
| " ^\n" + |
| "Y cannot be resolved to a type\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345359 |
| public void test0029a() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| " class I<T> {\n" + |
| " I(T t) {}\n" + |
| " }\n" + |
| " X.I<String> f = new X().new I<>(new Y()); \n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " X.I<String> f = new X().new I<>(new Y()); \n" + |
| " ^\n" + |
| "Y cannot be resolved to a type\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=346026 |
| public void test0030() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "class C {}\n" + |
| "interface I {}\n" + |
| "public class X<T extends C & I> {\n" + |
| " X() {}\n" + |
| " X f = new X<>();\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 5)\n" + |
| " X f = new X<>();\n" + |
| " ^\n" + |
| "X is a raw type. References to generic type X<T> should be parameterized\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=346026 |
| public void test0031() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "class C {}\n" + |
| "interface I {}\n" + |
| "public class X<T extends C & I> {\n" + |
| " X() {}\n" + |
| " X<?> f = new X<>();\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=346026 |
| public void test0032() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "class C {}\n" + |
| "interface I {}\n" + |
| "public class X<T extends C & I> {\n" + |
| " static <U extends C & I> X<U> getX() {\n" + |
| " return null;\n" + |
| " }\n" + |
| " X<?> f2 = getX();\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=346026 |
| public void test0033() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "class C {}\n" + |
| "interface I {}\n" + |
| "public class X<T extends C & I> {\n" + |
| " static <U extends C & I> X<U> getX() {\n" + |
| " return null;\n" + |
| " }\n" + |
| " X f2 = getX();\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 7)\n" + |
| " X f2 = getX();\n" + |
| " ^\n" + |
| "X is a raw type. References to generic type X<T> should be parameterized\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345559 |
| public void test0034() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X() {}\n" + |
| " void foo(T a) {\n" + |
| " System.out.println(a);\n" + |
| " }\n" + |
| " class Y<K>{\n" + |
| " Y(T t,K k) {}\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " X<Integer> x2 = new X<>(1);\n" + |
| " X<Integer> x3 = new X<>();\n" + |
| " X<Integer>.Y<String> y1 = new X<>(1,1).new Y<>();\n" + |
| " X<Integer>.Y<String> y2 = new X<>(1,1).new Y<>(1);\n" + |
| " X<Integer>.Y<String> y3 = new X<>(1).new Y<>(1);\n" + |
| " X<Integer>.Y<String> y4 = new X<>(1).new Y<>(\"\",\"\");\n" + |
| " X<Integer>.Y<String> y5 = new X<>(1).new Y<>(1,\"\");\n" + |
| " X<Integer>.Y<String> y6 = new X<>().new Y<>(1,\"\");\n" + |
| " X<Integer>.Y<String> y7 = new X<>().new Y<>(1,1);\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 11)\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 14)\n" + |
| " X<Integer>.Y<String> y1 = new X<>(1,1).new Y<>();\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 15)\n" + |
| " X<Integer>.Y<String> y2 = new X<>(1,1).new Y<>(1);\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 16)\n" + |
| " X<Integer>.Y<String> y3 = new X<>(1).new Y<>(1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for Y<>\n" + |
| "----------\n" + |
| "5. ERROR in X.java (at line 17)\n" + |
| " X<Integer>.Y<String> y4 = new X<>(1).new Y<>(\"\",\"\");\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for Y<>\n" + |
| "----------\n" + |
| "6. ERROR in X.java (at line 19)\n" + |
| " X<Integer>.Y<String> y6 = new X<>().new Y<>(1,\"\");\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.Y<String> to X<Integer>.Y<String>\n" |
| : |
| "Cannot infer type arguments for Y<>\n" |
| ) + |
| "----------\n" + |
| "7. ERROR in X.java (at line 20)\n" + |
| " X<Integer>.Y<String> y7 = new X<>().new Y<>(1,1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.Y<Integer> to X<Integer>.Y<String>\n" |
| : |
| "Cannot infer type arguments for Y<>\n" |
| ) + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345559 |
| public void test0034b() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X() {}\n" + |
| " void foo(T a) {\n" + |
| " System.out.println(a);\n" + |
| " }\n" + |
| " class Y<K>{\n" + |
| " Y(T t,K k) {}\n" + |
| " Y(K k) {}\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.Y<String> y42 = new X<>(\"\").new Y<>(\"\");\n" + |
| " X<String>.Y<String> y41 = new X<>(\"\").new Y<>(\"\",\"\");\n" + |
| " X<Integer>.Y<String> y4 = new X<>(1).new Y<>(\"\",\"\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 14)\n" + |
| " X<Integer>.Y<String> y4 = new X<>(1).new Y<>(\"\",\"\");\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for Y<>\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345559 |
| public void test0035() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X() {}\n" + |
| " @SafeVarargs\n" + |
| " X(String abc, String abc2, T... t) {}\n" + |
| " void foo(T a) {\n" + |
| " System.out.println(a);\n" + |
| " }\n" + |
| " class Y<K>{\n" + |
| " @SafeVarargs\n" + |
| " Y(T t,String abc, K... k) {}\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " X<Integer> x2 = new X<>(1);\n" + |
| " X<Integer> x3 = new X<>();\n" + |
| " X<Integer> x4 = new X<>(\"\",\"\");\n" + |
| " X<Integer> x5 = new X<>(\"\",\"\",\"\");\n" + |
| " X<Integer> x6 = new X<>(\"\",\"\",1);\n" + |
| " X<Integer>.Y<String> y1 = new X<>(1,1).new Y<>();\n" + |
| " X<Integer>.Y<String> y2 = new X<>(\"\",1).new Y<>(\"\");\n" + |
| " X<Integer>.Y<String> y3 = new X<>(1).new Y<>(1);\n" + |
| " X<Integer>.Y<String> y4 = new X<>(1).new Y<>(1,\"\");\n" + |
| " X<Integer>.Y<String> y5 = new X<>(1).new Y<>(1,\"\",\"\");\n" + |
| " X<Integer>.Y<String> y6 = new X<>().new Y<>(1,\"\",1);\n" + |
| " X<Integer>.Y<String> y7 = new X<>().new Y<>(\"\",\"\",1);\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 14)\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 18)\n" + |
| " X<Integer> x5 = new X<>(\"\",\"\",\"\");\n" + |
| " ^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<String> to X<Integer>\n" |
| : |
| "Cannot infer type arguments for X<>\n" |
| ) + |
| "----------\n" + |
| "3. ERROR in X.java (at line 20)\n" + |
| " X<Integer>.Y<String> y1 = new X<>(1,1).new Y<>();\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 21)\n" + |
| " X<Integer>.Y<String> y2 = new X<>(\"\",1).new Y<>(\"\");\n" + |
| " ^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "5. ERROR in X.java (at line 22)\n" + |
| " X<Integer>.Y<String> y3 = new X<>(1).new Y<>(1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for Y<>\n" + |
| "----------\n" + |
| "6. ERROR in X.java (at line 25)\n" + |
| " X<Integer>.Y<String> y6 = new X<>().new Y<>(1,\"\",1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.Y<Integer> to X<Integer>.Y<String>\n" |
| : |
| "Cannot infer type arguments for Y<>\n" |
| ) + |
| "----------\n" + |
| "7. ERROR in X.java (at line 26)\n" + |
| " X<Integer>.Y<String> y7 = new X<>().new Y<>(\"\",\"\",1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.Y<Integer> to X<Integer>.Y<String>\n" |
| : |
| "Cannot infer type arguments for Y<>\n" |
| ) + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345559 |
| public void test0036() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X() {}\n" + |
| " @SafeVarargs\n" + |
| " X(String abc, String abc2, T... t) {}\n" + |
| " void foo(T a) {\n" + |
| " System.out.println(a);\n" + |
| " }\n" + |
| " class Y<K>{\n" + |
| " @SafeVarargs\n" + |
| " Y(T t,String abc, K... k) {}\n" + |
| " }\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " X<Integer> x2 = new X<>(1);\n" + |
| " X<Integer> x3 = new X<>();\n" + |
| " X<Integer> x4 = new X<>(\"\",\"\");\n" + |
| " X<Integer> x5 = new X<>(\"\",\"\",\"\");\n" + |
| " X<Integer> x6 = new X<>(\"\",\"\",1);\n" + |
| " X<Integer>.Y<String> y1 = new X<>(1,1).new Y<>();\n" + |
| " X<Integer>.Y<String> y2 = new X<>(\"\",1).new Y<>(\"\");\n" + |
| " X<Integer>.Y<String> y3 = new X<>(1).new Y<>(1);\n" + |
| " X<Integer>.Y<String> y4 = new X<>(1).new Y<>(1,\"\");\n" + |
| " X<Integer>.Y<String> y5 = new X<>(1).new Y<>(1,\"\",\"\");\n" + |
| " X<Integer>.Y<String> y6 = new X<>().new Y<>(1,\"\",1);\n" + |
| " X<Integer>.Y<String> y7 = new X<>().new Y<>(\"\",\"\",1);\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 13)\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 17)\n" + |
| " X<Integer> x5 = new X<>(\"\",\"\",\"\");\n" + |
| " ^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<String> to X<Integer>\n" |
| : |
| "Cannot infer type arguments for X<>\n" |
| ) + |
| "----------\n" + |
| "3. ERROR in X.java (at line 19)\n" + |
| " X<Integer>.Y<String> y1 = new X<>(1,1).new Y<>();\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 20)\n" + |
| " X<Integer>.Y<String> y2 = new X<>(\"\",1).new Y<>(\"\");\n" + |
| " ^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "5. ERROR in X.java (at line 21)\n" + |
| " X<Integer>.Y<String> y3 = new X<>(1).new Y<>(1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for Y<>\n" + |
| "----------\n" + |
| "6. ERROR in X.java (at line 24)\n" + |
| " X<Integer>.Y<String> y6 = new X<>().new Y<>(1,\"\",1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.Y<Integer> to X<Integer>.Y<String>\n" |
| : |
| "Cannot infer type arguments for Y<>\n" |
| ) + |
| "----------\n" + |
| "7. ERROR in X.java (at line 25)\n" + |
| " X<Integer>.Y<String> y7 = new X<>().new Y<>(\"\",\"\",1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.Y<Integer> to X<Integer>.Y<String>\n" |
| : |
| "Cannot infer type arguments for Y<>\n" |
| ) + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345559 |
| public void test0034a() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X() {}\n" + |
| " void foo(T a) {\n" + |
| " System.out.println(a);\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " X<Integer> x2 = new X<>(1);\n" + |
| " X<Integer> x3 = new X<>();\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 8)\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345559 |
| public void test0035a() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X() {}\n" + |
| " @SafeVarargs\n" + |
| " X(String abc, String abc2, T... t) {}\n" + |
| " void foo(T a) {\n" + |
| " System.out.println(a);\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " X<Integer> x2 = new X<>(1);\n" + |
| " X<Integer> x3 = new X<>();\n" + |
| " X<Integer> x4 = new X<>(\"\",\"\");\n" + |
| " X<Integer> x5 = new X<>(\"\",\"\",\"\");\n" + |
| " X<Integer> x6 = new X<>(\"\",\"\",1);\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 10)\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 14)\n" + |
| " X<Integer> x5 = new X<>(\"\",\"\",\"\");\n" + |
| " ^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<String> to X<Integer>\n" |
| : |
| "Cannot infer type arguments for X<>\n" |
| ) + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345559 |
| public void test0036a() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X() {}\n" + |
| " @SafeVarargs\n" + |
| " X(String abc, String abc2, T... t) {}\n" + |
| " void foo(T a) {\n" + |
| " System.out.println(a);\n" + |
| " }\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " X<Integer> x2 = new X<>(1);\n" + |
| " X<Integer> x3 = new X<>();\n" + |
| " X<Integer> x4 = new X<>(\"\",\"\");\n" + |
| " X<Integer> x5 = new X<>(\"\",\"\",\"\");\n" + |
| " X<Integer> x6 = new X<>(\"\",\"\",1);\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 9)\n" + |
| " X<Integer> x1 = new X<>(1,1);\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 13)\n" + |
| " X<Integer> x5 = new X<>(\"\",\"\",\"\");\n" + |
| " ^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<String> to X<Integer>\n" |
| : |
| "Cannot infer type arguments for X<>\n" |
| ) + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345559 |
| public void test0037() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " X(T t) {}\n" + |
| " X() {}\n" + |
| " @SafeVarargs\n" + |
| " X(String abc, String abc2, T... t) {}\n" + |
| " void foo(T a) {\n" + |
| " System.out.println(a);\n" + |
| " }\n" + |
| " class Y<K>{\n" + |
| " @SafeVarargs\n" + |
| " Y(T t,String abc, K... k) {}\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Integer>.Y<String> y1 = new X<>().new Y<>(1);\n" + |
| " X<Integer>.Y<String> y2 = new X<>(1).new Y<>(1);\n" + |
| " X<Integer>.Y<String> y3 = new X<>(\"\",\"\",1).new Y<>(1);\n" + |
| " X<Integer>.Y<String> y4 = new X<>(1,\"\").new Y<>(1,\"\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 14)\n" + |
| " X<Integer>.Y<String> y1 = new X<>().new Y<>(1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for Y<>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 15)\n" + |
| " X<Integer>.Y<String> y2 = new X<>(1).new Y<>(1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for Y<>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 16)\n" + |
| " X<Integer>.Y<String> y3 = new X<>(\"\",\"\",1).new Y<>(1);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for Y<>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 17)\n" + |
| " X<Integer>.Y<String> y4 = new X<>(1,\"\").new Y<>(1,\"\");\n" + |
| " ^^^^^^^^^^^^^\n" + |
| "Cannot infer type arguments for X<>\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=341795 |
| public void test0038() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "interface A {\n" + |
| " <T extends B & C> T getaMethod();\n" + |
| " <T extends B & C> void setaMethod(T param);\n" + |
| "}\n" + |
| "class B {\n" + |
| "}\n" + |
| "interface C {\n" + |
| "}\n" + |
| "public class X {\n" + |
| " public void someMethod(A aInstance) {\n" + |
| " aInstance.getaMethod();\n" + |
| " }\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=319436 |
| public void test0039() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "import java.io.Serializable;\n" + |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " createObject();\n" + |
| " }\n" + |
| " private static <T extends Comparable<?> & Serializable> T createObject() {\n" + |
| " return null;\n" + |
| " }\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| public void test0042() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "interface I<T> {}\n" + |
| "public class X {\n" + |
| " <T extends I<T>> void m() { }\n" + |
| " { m(); } \n" + |
| "}\n" |
| }, |
| ""); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0043() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class Y<Z> {\n" + |
| " Y(T a, Z b) {\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.Y<String> x1 = new X<String>().new Y<String>(\"\",\"\");\n" + |
| " X<String>.Y<String> x2 = new X<String>().new Y<>(\"\",\"\");\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "SUCCESS"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0044() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class Y<Z> {\n" + |
| " Y(T a, Z b) {\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.Y<String> x = new X<>().new Y<>(\"\",\"\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 7)\n" + |
| " X<String>.Y<String> x = new X<>().new Y<>(\"\",\"\");\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "Type mismatch: cannot convert from X<Object>.Y<String> to X<String>.Y<String>\n" |
| : |
| "Cannot infer type arguments for Y<>\n" |
| ) + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0045() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| " class Y<T, Z> {\n" + |
| " Y(T a, Z b) {\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X.Y<String, String> x = new X().new Y<>(\"\",\"\");\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "SUCCESS"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0046() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class Y<Z> {\n" + |
| " Y(T a, Z b) { \n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.Y<String> x = new X<String>().new Y<>(\"\",\"\");\n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "SUCCESS"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0047() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class Y<Z> {\n" + |
| " Y(T a, Z b) {\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.Y<String> x1 = new X<String>().new Y<String>(\"\",\"\"); \n" + |
| " X<String>.Y<String> x2 = new X<String>().new Y<>(\"\",\"\"); // javac wrong error \n" + |
| " System.out.println(\"SUCCESS\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "SUCCESS"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0048() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " <T> X(T t) {\n" + |
| " }\n" + |
| " X<String> x = new X<>(\"\"); \n" + |
| " Zork z;\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 2)\n" + |
| " <T> X(T t) {\n" + |
| " ^\n" + |
| "The type parameter T is hiding the type T\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 5)\n" + |
| " Zork z;\n" + |
| " ^^^^\n" + |
| "Zork cannot be resolved to a type\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0049() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T> {\n" + |
| " class Y<Z> {\n" + |
| " Y(T a, Z b) {\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Object>.Y<String> x1 = new X<Object>().new Y<String>(new Object(),\"\");\n" + |
| " X<Object>.Y<String> x2 = new X<>().new Y<String>(new Object(),\"\");\n" + |
| " X<Object>.Y<String> x3 = new X<Object>().new Y<>(new Object(),\"\");\n" + |
| " X<Object>.Y<String> x4 = new X<>().new Y<>(new Object(),\"\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0050() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T extends Comparable<T>> {\n" + |
| " class Y<Z> {\n" + |
| " Y(T a, Z b) {\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.Y<String> x1 = new X<String>().new Y<>(\"\",\"\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=345968 |
| public void test0051() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X<T extends Comparable<T>> {\n" + |
| " class Y<Z> {\n" + |
| " Y(Integer a, Z b) {\n" + |
| " }\n" + |
| " Y(T a, Z b) {\n" + |
| " }\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " X<String>.Y<String> x1 = new X<String>().new Y<>(\"\",\"\");\n" + |
| " }\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0052() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<E> {\n" + |
| " X(E e) {}\n" + |
| " X() {}\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Number> x = new X<Number>(1);\n" + |
| " X<String> x2 = new X<String>(\"SUCCESS\");\n" + |
| " X<Integer> x3 = new X<Integer>(1);\n" + |
| " X<AX> x4 = new X<AX>(new AX());\n" + |
| " X<? extends AX> x5 = new X<AX<String>>(new AX<String>());\n" + |
| " X<?> x6 = new X<AX<String>>(new AX<String>());\n" + |
| " X<Class<? extends Object>> x7 = new X<Class<? extends Object>>();\n" + |
| " }\n" + |
| "}\n" + |
| "class AX<T>{}\n" |
| }, |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "----------\n" + |
| "1. ERROR in X.java (at line 6)\n" + |
| " X<String> x2 = new X<String>(\"SUCCESS\");\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <String>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 7)\n" + |
| " X<Integer> x3 = new X<Integer>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 8)\n" + |
| " X<AX> x4 = new X<AX>(new AX());\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <AX>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 9)\n" + |
| " X<? extends AX> x5 = new X<AX<String>>(new AX<String>());\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <AX<String>>\n" + |
| "----------\n" + |
| "5. ERROR in X.java (at line 10)\n" + |
| " X<?> x6 = new X<AX<String>>(new AX<String>());\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <AX<String>>\n" + |
| "----------\n" + |
| "6. ERROR in X.java (at line 11)\n" + |
| " X<Class<? extends Object>> x7 = new X<Class<? extends Object>>();\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Class<? extends Object>>\n" + |
| "----------\n" |
| : // additional error at line 5 due to better inference: |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " X<Number> x = new X<Number>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Number>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 6)\n" + |
| " X<String> x2 = new X<String>(\"SUCCESS\");\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <String>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 7)\n" + |
| " X<Integer> x3 = new X<Integer>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 8)\n" + |
| " X<AX> x4 = new X<AX>(new AX());\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <AX>\n" + |
| "----------\n" + |
| "5. ERROR in X.java (at line 9)\n" + |
| " X<? extends AX> x5 = new X<AX<String>>(new AX<String>());\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <AX<String>>\n" + |
| "----------\n" + |
| "6. ERROR in X.java (at line 10)\n" + |
| " X<?> x6 = new X<AX<String>>(new AX<String>());\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <AX<String>>\n" + |
| "----------\n" + |
| "7. ERROR in X.java (at line 11)\n" + |
| " X<Class<? extends Object>> x7 = new X<Class<? extends Object>>();\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Class<? extends Object>>\n" + |
| "----------\n" |
| ), |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0052b() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<E> {\n" + |
| " E eField;\n" + |
| " E get() { return this.eField; }\n" + |
| " X(E e) {}\n" + |
| " X(int e, String e2) {}\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Number> x = new X<Number>(1);\n" + |
| " X<String> x2 = new X<String>(\"SUCCESS\");\n" + |
| " X<String> x22 = new X<String>(1,\"SUCCESS\");\n" + |
| " X<Integer> x3 = new X<Integer>(1);\n" + |
| " String s = foo(new X<String>(\"aaa\"));\n" + |
| " String s2 = foo(new X<String>(1,\"aaa\"));\n" + |
| " }\n" + |
| " static String foo(X<String> x) {\n" + |
| " return x.get();\n" + |
| " }\n" + |
| "}\n" |
| }, |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "----------\n" + |
| "1. ERROR in X.java (at line 8)\n" + |
| " X<String> x2 = new X<String>(\"SUCCESS\");\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <String>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 9)\n" + |
| " X<String> x22 = new X<String>(1,\"SUCCESS\");\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <String>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 10)\n" + |
| " X<Integer> x3 = new X<Integer>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 11)\n" + |
| " String s = foo(new X<String>(\"aaa\"));\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <String>\n" + |
| "----------\n" |
| : // additional error at line 7 due to better inference |
| "----------\n" + |
| "1. ERROR in X.java (at line 7)\n" + |
| " X<Number> x = new X<Number>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Number>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 8)\n" + |
| " X<String> x2 = new X<String>(\"SUCCESS\");\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <String>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 9)\n" + |
| " X<String> x22 = new X<String>(1,\"SUCCESS\");\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <String>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 10)\n" + |
| " X<Integer> x3 = new X<Integer>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "5. ERROR in X.java (at line 11)\n" + |
| " String s = foo(new X<String>(\"aaa\"));\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <String>\n" + |
| "----------\n" |
| ), |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0052c() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<E> {\n" + |
| " X(String abc, String def) {}\n" + |
| " void foo() {\n" + |
| " X<Integer> x = new X<Integer>(\"\",\"\");\n" + |
| " foo3(new X<Integer>(\"\",\"\"));\n" + |
| " }\n" + |
| " X<Integer> foo2() {\n" + |
| " return new X<Integer>(\"\",\"\");\n" + |
| " }\n" + |
| " void foo3(X<Integer> x) {}\n" + |
| "}" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 4)\n" + |
| " X<Integer> x = new X<Integer>(\"\",\"\");\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 8)\n" + |
| " return new X<Integer>(\"\",\"\");\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0052d() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<E> {\n" + |
| " X(E e) {}\n" + |
| " X() {}\n" + |
| " public static void main(String[] args) {\n" + |
| " X<Number> x = new X<Number>(1);\n" + |
| " }\n" + |
| "}\n" + |
| "class AX<T>{}\n" |
| }, |
| this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "" : |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " X<Number> x = new X<Number>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Number>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0053() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "Z.java", |
| "public class Z <T extends ZB> { \n" + |
| " public static void main(String[] args) {\n" + |
| " foo(new Z<ZB>());\n" + |
| " }\n" + |
| " static void foo(Z<ZB> z) {\n" + |
| " }\n" + |
| "}\n" + |
| "class ZB {\n" + |
| "}" |
| }, |
| "----------\n" + |
| "1. ERROR in Z.java (at line 3)\n" + |
| " foo(new Z<ZB>());\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <ZB>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0054() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "Y.java", |
| "public class Y<V> {\n" + |
| " public static <W extends ABC> Y<W> make(Class<W> clazz) {\n" + |
| " return new Y<W>();\n" + |
| " }\n" + |
| "}\n" + |
| "class ABC{}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in Y.java (at line 3)\n" + |
| " return new Y<W>();\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <W>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0055() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X<A> {\n" + |
| " class Inner<B> { }\n" + |
| " static class Inner2<C> { }\n" + |
| "\n" + |
| " void method() {\n" + |
| " X<String>.Inner<Integer> a= new X<String>().new Inner<Integer>();\n" + |
| " X<String>.Inner<Integer> a1= new X<String>().new Inner<>();\n" + // do not warn. Removing String from X<String> not possible |
| " Inner<Integer> b= new X<A>().new Inner<Integer>();\n" + |
| " Inner<Integer> c= new Inner<Integer>();\n" + |
| " X<A>.Inner<Integer> e= new X<A>().new Inner<Integer>();\n" + |
| " X<A>.Inner<Integer> f= new Inner<Integer>();\n" + |
| " X.Inner2<Integer> d3 = new X.Inner2<Integer>();\n" + |
| " }\n" + |
| "}\n", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 6)\n" + |
| " X<String>.Inner<Integer> a= new X<String>().new Inner<Integer>();\n" + |
| " ^^^^^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 8)\n" + |
| " Inner<Integer> b= new X<A>().new Inner<Integer>();\n" + |
| " ^^^^^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 9)\n" + |
| " Inner<Integer> c= new Inner<Integer>();\n" + |
| " ^^^^^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 10)\n" + |
| " X<A>.Inner<Integer> e= new X<A>().new Inner<Integer>();\n" + |
| " ^^^^^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "5. ERROR in X.java (at line 11)\n" + |
| " X<A>.Inner<Integer> f= new Inner<Integer>();\n" + |
| " ^^^^^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "6. ERROR in X.java (at line 12)\n" + |
| " X.Inner2<Integer> d3 = new X.Inner2<Integer>();\n" + |
| " ^^^^^^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| // qualified allocation |
| public void test0056() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X <T> {\n" + |
| " void foo1() {\n" + |
| " X<String>.Item<Thread> i = new X<Exception>().new Item<Thread>();\n" + |
| " }\n" + |
| " void foo2() {\n" + |
| " X<Exception>.Item<Thread> j = new X<Exception>.Item<Thread>();\n" + |
| " }\n" + |
| " class Item <E> {}\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 3)\n" + |
| " X<String>.Item<Thread> i = new X<Exception>().new Item<Thread>();\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Type mismatch: cannot convert from X<Exception>.Item<Thread> to X<String>.Item<Thread>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 3)\n" + |
| " X<String>.Item<Thread> i = new X<Exception>().new Item<Thread>();\n" + |
| " ^^^^\n" + |
| "Redundant specification of type arguments <Thread>\n" + |
| "----------\n" + |
| "3. ERROR in X.java (at line 6)\n" + |
| " X<Exception>.Item<Thread> j = new X<Exception>.Item<Thread>();\n" + |
| " ^^^^^^^^^^^^^^^^^\n" + |
| "Cannot allocate the member type X<Exception>.Item<Thread> using a parameterized compound name; use its simple name and an enclosing instance of type X<Exception>\n" + |
| "----------\n" + |
| "4. ERROR in X.java (at line 6)\n" + |
| " X<Exception>.Item<Thread> j = new X<Exception>.Item<Thread>();\n" + |
| " ^^^^\n" + |
| "Redundant specification of type arguments <Thread>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| // qualified allocation |
| public void test0056b() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X <T> {\n" + |
| " static class X1<Z> {\n" + |
| " X1(Z z){}\n" + |
| " }\n" + |
| " X1<Integer> x1 = new X.X1<Integer>(1);\n" + |
| " X1<Number> x2 = new X.X1<Number>(1);\n" + |
| "}\n" |
| }, |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " X1<Integer> x1 = new X.X1<Integer>(1);\n" + |
| " ^^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" |
| : // additional error at line 6 due to better inference: |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " X1<Integer> x1 = new X.X1<Integer>(1);\n" + |
| " ^^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 6)\n" + |
| " X1<Number> x2 = new X.X1<Number>(1);\n" + |
| " ^^\n" + |
| "Redundant specification of type arguments <Number>\n" + |
| "----------\n" |
| ), |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| // qualified allocation |
| public void test0056c() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X <T> {\n" + |
| " X(T t){}\n" + |
| " class X1<Z> {\n" + |
| " X1(Z z){}\n" + |
| " }\n" + |
| " X<Integer>.X1<Number> x1 = new X<Integer>(1).new X1<Number>(1);\n" + |
| "}\n" |
| }, |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "----------\n" + |
| "1. ERROR in X.java (at line 6)\n" + |
| " X<Integer>.X1<Number> x1 = new X<Integer>(1).new X1<Number>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" |
| : // additional error (2.) at inner allocation due to better inference: |
| "----------\n" + |
| "1. ERROR in X.java (at line 6)\n" + |
| " X<Integer>.X1<Number> x1 = new X<Integer>(1).new X1<Number>(1);\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <Integer>\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 6)\n" + |
| " X<Integer>.X1<Number> x1 = new X<Integer>(1).new X1<Number>(1);\n" + |
| " ^^\n" + |
| "Redundant specification of type arguments <Number>\n" + |
| "----------\n" |
| ), |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0057() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| " void test() {\n" + |
| " Pair<Double, Integer> p = new InvertedPair<Integer, Double>();\n" + |
| " }\n" + |
| "}\n" + |
| "class Pair<A, B> {\n" + |
| "}\n" + |
| "class InvertedPair<A, B> extends Pair<B, A> {\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 3)\n" + |
| " Pair<Double, Integer> p = new InvertedPair<Integer, Double>();\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Redundant specification of type arguments <Integer, Double>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0058() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.ArrayList;\n" + |
| "\n" + |
| "public class X {\n" + |
| " public void test(boolean param) {\n" + |
| " ArrayList<?> ls = (param) \n" + |
| " ? new ArrayList<String>()\n" + |
| " : new ArrayList<Object>();\n" + |
| " \n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 7)\n" + |
| " : new ArrayList<Object>();\n" + |
| " ^^^^^^^^^\n" + |
| "Redundant specification of type arguments <Object>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=340747 |
| public void test0059() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| customOptions.put(CompilerOptions.OPTION_ReportRawTypeReference, CompilerOptions.IGNORE); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.ArrayList;\n" + |
| "import java.util.List;\n" + |
| "\n" + |
| "public class X<T> {\n" + |
| " X(List<? extends T> p) {}\n" + |
| " Object x = new X<CharSequence>((ArrayList<String>) null);\n" + |
| "}\n" |
| }, |
| "", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=351965 |
| public void test0060() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_4); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.util.ArrayList;\n" + |
| "import java.util.List;\n" + |
| "\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " new ArrayList<>();\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 6)\n" + |
| " new ArrayList<>();\n" + |
| " ^^^^^^^^^\n" + |
| "\'<>\' operator is not allowed for source level below 1.7\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 6)\n" + |
| " new ArrayList<>();\n" + |
| " ^^^^^^^^^\n" + |
| "Incorrect number of arguments for type ArrayList<E>; it cannot be parameterized with arguments <>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=351965 |
| public void test0060a() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_4); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " new java.util.ArrayList<>();\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 4)\n" + |
| " new java.util.ArrayList<>();\n" + |
| " ^^^^^^^^^^^^^^^^^^^\n" + |
| "\'<>\' operator is not allowed for source level below 1.7\n" + |
| "----------\n" + |
| "2. ERROR in X.java (at line 4)\n" + |
| " new java.util.ArrayList<>();\n" + |
| " ^^^^^^^^^^^^^^^^^^^\n" + |
| "Incorrect number of arguments for type ArrayList<E>; it cannot be parameterized with arguments <>\n" + |
| "----------\n", |
| null, |
| false, |
| customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=361441 |
| public void test0061() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "import java.net.URI;" + |
| "import java.nio.file.FileSystems;" + |
| "import java.util.Collections;\n" + |
| "public class X {\n" + |
| " public static void foo() {\n" + |
| " URI uri = URI.create(\"http://www.eclipse.org\");\n" + |
| " FileSystems.<String, Object>newFileSystem(uri, Collections.emptyMap());\n" + |
| " }\n" + |
| "}\n" |
| }, |
| (this.complianceLevel < ClassFileConstants.JDK1_8 ? |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " FileSystems.<String, Object>newFileSystem(uri, Collections.emptyMap());\n" + |
| " ^^^^^^^^^^^^^\n" + |
| "The method newFileSystem(URI, Map<String,?>) in the type FileSystems is not applicable for the arguments (URI, Map<Object,Object>)\n" + |
| "----------\n" |
| : // with better inference, method is applicable, but then we have another problem: |
| "----------\n" + |
| "1. ERROR in X.java (at line 5)\n" + |
| " FileSystems.<String, Object>newFileSystem(uri, Collections.emptyMap());\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Unhandled exception type IOException\n" + |
| "----------\n" + |
| "2. WARNING in X.java (at line 5)\n" + |
| " FileSystems.<String, Object>newFileSystem(uri, Collections.emptyMap());\n" + |
| " ^^^^^^^^^^^^^^\n" + |
| "Unused type arguments for the non generic method newFileSystem(URI, Map<String,?>) of type FileSystems; it should not be parameterized with arguments <String, Object>\n" + |
| "----------\n" |
| )); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=428220, [1.8][compiler] Javadoc processing interferes with type inference. |
| public void test428220() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_DocCommentSupport, CompilerOptions.ENABLED); |
| runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class HashMap<K, V> {\n" + |
| " static class Node<K, V> {\n" + |
| " Node(int hash, K key, V value, Node<K, V> next) {}\n" + |
| " }\n" + |
| " /** @see #put(Object, Object) */\n" + |
| " public V put(K key, V value) { return null; }\n" + |
| "\n" + |
| " Node<K, V> newNode(int hash, K key, V value, Node<K, V> next) {\n" + |
| " return new Node<>(hash, key, value, next); // Error\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 1)\n" + |
| " public class HashMap<K, V> {\n" + |
| " ^^^^^^^\n" + |
| "The public type HashMap must be defined in its own file\n" + |
| "----------\n", null, true, customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=428220, [1.8][compiler] Javadoc processing interferes with type inference. |
| public void test428220a() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_Store_Annotations, CompilerOptions.ENABLED); |
| runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class HashMap<K, V> {\n" + |
| " static class Node<K, V> {\n" + |
| " Node(int hash, K key, V value, Node<K, V> next) {}\n" + |
| " }\n" + |
| " /** @see #put(Object, Object) */\n" + |
| " public V put(K key, V value) { return null; }\n" + |
| "\n" + |
| " Node<K, V> newNode(int hash, K key, V value, Node<K, V> next) {\n" + |
| " return new Node<>(hash, key, value, next); // Error\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 1)\n" + |
| " public class HashMap<K, V> {\n" + |
| " ^^^^^^^\n" + |
| "The public type HashMap must be defined in its own file\n" + |
| "----------\n", null, true, customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=442929, [1.8][compiler] ClassCastException during runtime where is no cast |
| public void test442929() { |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " shouldNotThrow();\n" + |
| " }\n" + |
| " static void shouldNotThrow() {\n" + |
| " final String[] array = { \"\" };\n" + |
| " final String[] expected = { \"\" };\n" + |
| " // throws\n" + |
| " try {\n" + |
| " assertThat(op(array, \"\")).isEqualTo(expected);\n" + |
| " } catch (ClassCastException c) {\n" + |
| " System.out.println(\"Expected CCE\");\n" + |
| " }\n" + |
| " }\n" + |
| " static <T> T[] op(T[] array, T element) {\n" + |
| " return asArray(element);\n" + |
| " }\n" + |
| " @SafeVarargs\n" + |
| " static <T> T[] asArray(T... elements) {\n" + |
| " return elements;\n" + |
| " }\n" + |
| " static <T> ObjectArrayAssert<T> assertThat(T actual) {\n" + |
| " return new ObjectArrayAssert<>(actual);\n" + |
| " }\n" + |
| " static class ObjectArrayAssert<T> {\n" + |
| " ObjectArrayAssert(T actual) {\n" + |
| " }\n" + |
| " void isEqualTo(T expected) {\n" + |
| " }\n" + |
| " }\n" + |
| "}\n", |
| }, |
| "Expected CCE"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=448028, [1.8] 1.8 cannot infer type arguments where 1.7 does |
| public void test448028() { |
| Map customOptions = getCompilerOptions(); |
| customOptions.put(CompilerOptions.OPTION_ReportRedundantSpecificationOfTypeArguments, CompilerOptions.ERROR); |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| "\n" + |
| " public static interface I {/*empty*/}\n" + |
| "\n" + |
| " public static class C\n" + |
| " implements I {/*empty*/}\n" + |
| "\n" + |
| " public static class W<T extends I>\n" + |
| " implements I {\n" + |
| "\n" + |
| " // --- problem is triggered only, when there is a vararg-parameter\n" + |
| " public W(final T t, final Object... o) {\n" + |
| " super();\n" + |
| " }\n" + |
| " }\n" + |
| "\n" + |
| " // --- needed to trigger problem\n" + |
| " public static final <T> T inspect(final T t) {\n" + |
| " return t;\n" + |
| " }\n" + |
| "\n" + |
| " // --- this compiles ok when having JDK Compilance set to 1.7 !\n" + |
| " public static final W<C> err1() {\n" + |
| " final C c = new C();\n" + |
| " final Object o = new Object();\n" + |
| " return inspect(new W<>(c, o)); // - ERROR: Cannot infer type arguments for W<> F.java\n" + |
| " }\n" + |
| "\n" + |
| " public static final W<C> wrn1() {\n" + |
| " final C c = new C();\n" + |
| " final Object o = new Object();\n" + |
| " // --- giving the type-parameter yields a warning\n" + |
| " // --- comparing that to the error of method err1() it does not make much sense\n" + |
| " return inspect(new W<C>(c, o)); // - WARNING: Redundant specification of type arguments <F.C> F.java\n" + |
| " }\n" + |
| "\n" + |
| " public static final W<C> ok1() {\n" + |
| " final C c = new C();\n" + |
| " // --- no extra vararg-paramaeter\n" + |
| " return inspect(new W<>(c)); // - OK\n" + |
| " }\n" + |
| "\n" + |
| " public static final W<C> ok2() {\n" + |
| " final C c = new C();\n" + |
| " final Object o = new Object();\n" + |
| " // --- no check-method\n" + |
| " return new W<>(c, o); // - OK\n" + |
| " }\n" + |
| "\n" + |
| " public static final W<C> ok3() {\n" + |
| " final C c = new C();\n" + |
| " // --- no check-method\n" + |
| " return new W<>(c); // - OK\n" + |
| " }\n" + |
| "\n" + |
| " public static final W<C> ok4() {\n" + |
| " final C c = new C();\n" + |
| " final Object o = new Object();\n" + |
| " // --- this also compiles (my solution for now)\n" + |
| " final W<C> w = new W<>(c, o);\n" + |
| " return inspect(w);\n" + |
| " }\n" + |
| "}\n", |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 34)\n" + |
| " return inspect(new W<C>(c, o)); // - WARNING: Redundant specification of type arguments <F.C> F.java\n" + |
| " ^\n" + |
| "Redundant specification of type arguments <X.C>\n" + |
| "----------\n", |
| null, false, customOptions); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=449619, [1.8][compiler] Qualified <> allocation fails to compile. |
| public void test449619() { |
| String source = "public class X {\n" + |
| " public class Y<T> {\n" + |
| " }\n" + |
| " static void foo(Y<String> ys) {\n" + |
| " }\n" + |
| " public static void main(String[] args) {\n" + |
| " foo(new X().new Y<>());\n" + |
| " }\n" + |
| "}\n"; |
| if (this.complianceLevel >= ClassFileConstants.JDK1_8) |
| this.runConformTest( |
| new String[] { |
| "X.java", |
| source, |
| }, |
| ""); |
| else |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| source, |
| }, |
| "----------\n" + |
| "1. ERROR in X.java (at line 7)\n" + |
| " foo(new X().new Y<>());\n" + |
| " ^^^\n" + |
| "The method foo(X.Y<String>) in the type X is not applicable for the arguments (X.Y<Object>)\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=429733, [1.8][bytecode] Bad type on operand stack |
| public void test429733() { |
| runConformTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " test(new Some<>(1.1d));\n" + |
| " }\n" + |
| " static <S> void test(Option<S> value) {\n" + |
| " }\n" + |
| " static interface Option<T> {\n" + |
| " }\n" + |
| " static class Some<T> implements Option<T> {\n" + |
| " Some(T value) {\n" + |
| " System.out.println(value);\n" + |
| " }\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "1.1"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=429733, [1.8][bytecode] Bad type on operand stack |
| public void test429733a() { |
| runConformTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " test(new Some<Double>(1.1d));\n" + |
| " }\n" + |
| " static <S> void test(Option<S> value) {\n" + |
| " }\n" + |
| " static interface Option<T> {\n" + |
| " }\n" + |
| " static class Some<T> implements Option<T> {\n" + |
| " Some(T value) {\n" + |
| " System.out.println(value);\n" + |
| " }\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "1.1"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=375394 |
| public void test375394a() { |
| this.runNegativeTest( |
| new String[] { |
| "X.java", |
| "public class X {\n" + |
| " B<C, ? extends C<C>, ? extends C<C>> b = new B<>();\n" + |
| "}\n" + |
| "class B <T, U extends C<T>, V extends U>{}\n" + |
| "class C<T> {}\n", |
| }, |
| "----------\n" + |
| "1. WARNING in X.java (at line 2)\n" + |
| " B<C, ? extends C<C>, ? extends C<C>> b = new B<>();\n" + |
| " ^\n" + |
| "C is a raw type. References to generic type C<T> should be parameterized\n" + |
| "----------\n" + |
| "2. WARNING in X.java (at line 2)\n" + |
| " B<C, ? extends C<C>, ? extends C<C>> b = new B<>();\n" + |
| " ^\n" + |
| "C is a raw type. References to generic type C<T> should be parameterized\n" + |
| "----------\n" + |
| "3. WARNING in X.java (at line 2)\n" + |
| " B<C, ? extends C<C>, ? extends C<C>> b = new B<>();\n" + |
| " ^\n" + |
| "C is a raw type. References to generic type C<T> should be parameterized\n" + |
| "----------\n"); |
| } |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=427728, [1.8] Type Inference rejects calls requiring boxing/unboxing |
| public void test427728b() { |
| runConformTest( |
| new String[] { |
| "X.java", |
| "import java.util.Collections;\n" + |
| "import java.util.LinkedHashMap;\n" + |
| "import java.util.Map;\n" + |
| "public class X {\n" + |
| " public static void main(String[] args) {\n" + |
| " Map<X, Integer> map = new LinkedHashMap<>();\n" + |
| " map.put(null, X.getInt());\n" + |
| " map.put(null, X.getint());\n" + |
| " }\n" + |
| " private static <T> int getInt() {\n" + |
| " return 0;\n" + |
| " }\n" + |
| " private static int getint() {\n" + |
| " return 0;\n" + |
| " }\n" + |
| "}\n" |
| }, |
| ""); |
| } |
| public void testBug456508() { |
| runNegativeTest( |
| new String[] { |
| "QueryAtom.java", |
| "public class QueryAtom<T, P> {\n" + |
| " public QueryAtom(SingularAttribute<? super T, P> path) {\n" + |
| " }\n" + |
| "}\n", |
| "SubqueryIn.java", |
| "public class SubqueryIn<S, P> {\n" + |
| " public SubqueryIn(QueryAtom<S, P>... subqueryAtoms) {\n" + |
| " }\n" + |
| "}\n", |
| "Test.java", |
| "class PAccount {}\n" + |
| "class PGroepAccount {}\n" + |
| "interface SingularAttribute<X, T> {}\n" + |
| "\n" + |
| "public class Test {\n" + |
| " public static volatile SingularAttribute<PGroepAccount, PAccount> account;\n" + |
| "\n" + |
| " public void nietInGroep() {\n" + |
| " recordFilter(new SubqueryIn<>(new QueryAtom<>(account)));\n" + |
| " }\n" + |
| "\n" + |
| " protected <P> void recordFilter(SubqueryIn<?, P> atom) {\n" + |
| " }\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| "1. WARNING in SubqueryIn.java (at line 2)\n" + |
| " public SubqueryIn(QueryAtom<S, P>... subqueryAtoms) {\n" + |
| " ^^^^^^^^^^^^^\n" + |
| "Type safety: Potential heap pollution via varargs parameter subqueryAtoms\n" + |
| "----------\n" + |
| "----------\n" + |
| "1. WARNING in Test.java (at line 9)\n" + |
| " recordFilter(new SubqueryIn<>(new QueryAtom<>(account)));\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Type safety: A generic array of QueryAtom<PGroepAccount,PAccount> is created for a varargs parameter\n" + |
| "----------\n"); |
| } |
| public void testBug462083() { |
| runConformTest( |
| new String[] { |
| "Java8InterfaceTest.java", |
| "public abstract class Java8InterfaceTest\n" + |
| "{\n" + |
| " public static interface Entity {}\n" + |
| "\n" + |
| " public static interface Service<T1 extends Entity> {}\n" + |
| "\n" + |
| " public static interface ServiceLocator<T2 extends Entity> {}\n" + |
| "\n" + |
| " public static class ConcreteClass<T3 extends Entity, S extends Service<T3>> implements ServiceLocator<T3> {}\n" + |
| "\n" + |
| " protected abstract <T4 extends Entity> ConcreteClass<T4, ?> getParameterized(T4 entity);\n" + |
| "\n" + |
| " protected <T5 extends Entity> ServiceLocator<T5> getInterface(T5 entity)\n" + |
| " {\n" + |
| " return getParameterized(entity);\n" + |
| " }\n" + |
| "}\n" |
| }); |
| } |
| public void testBug469653() { |
| String codeContent = |
| "import java.util.*;\n" + |
| "\n" + |
| "class ImmutableList<E> {\n" + |
| " static <F> ImmutableList<F> copyOf(Iterable<? extends F> in) { return null; }\n" + |
| " ImmutableList<E> reverse() { return this; }\n" + |
| " Iterator<E> iterator() { return null; }\n" + |
| "}\n" + |
| "public class Code {\n" + |
| " public static void test() {\n" + |
| " Iterable<? extends String> services = null;\n" + |
| " Iterator<String> reverseServices = ImmutableList.copyOf(services).reverse().iterator();\n" + |
| " }\n" + |
| "}"; |
| if (this.complianceLevel < ClassFileConstants.JDK1_8) { |
| runConformTest( |
| new String[] { "Code.java", codeContent }); |
| } else { |
| runNegativeTest( |
| new String[] { "Code.java", codeContent }, |
| "----------\n" + |
| "1. ERROR in Code.java (at line 11)\n" + |
| " Iterator<String> reverseServices = ImmutableList.copyOf(services).reverse().iterator();\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Type mismatch: cannot convert from Iterator<capture#1-of ? extends String> to Iterator<String>\n" + |
| "----------\n"); |
| } |
| } |
| public void testBug488649_JDK6791481_ex1() { |
| int count = 1; |
| runNegativeTest( |
| new String[] { |
| "Test.java", |
| "class Test<X> {\n" + |
| " X m(Class<X> c) {return null;}\n" + |
| " X x = m((Class)String.class);\n" + |
| "}\n" |
| }, |
| "----------\n" + |
| (this.complianceLevel >= ClassFileConstants.JDK1_8 |
| ? |
| (count++)+". ERROR in Test.java (at line 3)\n" + |
| " X x = m((Class)String.class);\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Type mismatch: cannot convert from Object to X\n" + // <- want to see this error, but at 1.7- we keep javac compatibility |
| "----------\n" |
| : |
| "" |
| )+ |
| (count++)+". WARNING in Test.java (at line 3)\n" + |
| " X x = m((Class)String.class);\n" + |
| " ^^^^^^^^^^^^^^^^^^^\n" + |
| "Type safety: The expression of type Class needs unchecked conversion to conform to Class<X>\n" + |
| "----------\n" + |
| (count++)+". WARNING in Test.java (at line 3)\n" + |
| " X x = m((Class)String.class);\n" + |
| " ^^^^^\n" + |
| "Class is a raw type. References to generic type Class<T> should be parameterized\n" + |
| "----------\n"); |
| } |
| public static Class testClass() { |
| return GenericsRegressionTest_1_7.class; |
| } |
| } |