From 30039b5085f68f5deddfb20c6b1df36a65b11ab5 Mon Sep 17 00:00:00 2001 From: Pavel Dolgov Date: Mon, 13 Mar 2017 17:43:29 +0300 Subject: [PATCH] Java: Added quick fix tests for "MethodHandle/VarHandle type mismatch" inspection (IDEA-167318) --- .../invokeHandle/afterConstructor.java | 14 +++++++ .../invokeHandle/afterConstructor2.java | 13 +++++++ .../invokeHandle/afterConstructor3.java | 12 ++++++ .../invokeHandle/afterConstructor4.java | 14 +++++++ .../invokeHandle/afterGenericMethod.java | 15 ++++++++ .../invokeHandle/afterGenericMethod2.java | 15 ++++++++ .../invokeHandle/afterGenericMethod3.java | 15 ++++++++ .../invokeHandle/afterGenericMethod4.java | 15 ++++++++ .../quickFix/invokeHandle/afterGetter.java | 13 +++++++ .../quickFix/invokeHandle/afterGetter2.java | 13 +++++++ .../quickFix/invokeHandle/afterSetter.java | 13 +++++++ .../quickFix/invokeHandle/afterSetter2.java | 13 +++++++ .../invokeHandle/afterStaticGetter.java | 13 +++++++ .../invokeHandle/afterStaticGetter2.java | 13 +++++++ .../invokeHandle/afterStaticMethod.java | 15 ++++++++ .../invokeHandle/afterStaticMethod2.java | 15 ++++++++ .../invokeHandle/afterStaticMethod3.java | 15 ++++++++ .../invokeHandle/afterStaticMethod4.java | 13 +++++++ .../invokeHandle/afterStaticSetter.java | 13 +++++++ .../invokeHandle/afterStaticSetter2.java | 13 +++++++ .../invokeHandle/afterStaticVarHandle.java | 13 +++++++ .../invokeHandle/afterStaticVarHandle2.java | 13 +++++++ .../quickFix/invokeHandle/afterVarHandle.java | 13 +++++++ .../invokeHandle/afterVarHandle2.java | 13 +++++++ .../invokeHandle/afterVirtualMethod.java | 15 ++++++++ .../invokeHandle/afterVirtualMethod2.java | 15 ++++++++ .../invokeHandle/afterVirtualMethod3.java | 15 ++++++++ .../invokeHandle/afterVirtualMethod4.java | 13 +++++++ .../invokeHandle/beforeConstructor.java | 14 +++++++ .../invokeHandle/beforeConstructor2.java | 13 +++++++ .../invokeHandle/beforeConstructor3.java | 12 ++++++ .../invokeHandle/beforeConstructor4.java | 14 +++++++ .../invokeHandle/beforeGenericMethod.java | 15 ++++++++ .../invokeHandle/beforeGenericMethod2.java | 15 ++++++++ .../invokeHandle/beforeGenericMethod3.java | 15 ++++++++ .../invokeHandle/beforeGenericMethod4.java | 15 ++++++++ .../quickFix/invokeHandle/beforeGetter.java | 13 +++++++ .../quickFix/invokeHandle/beforeGetter2.java | 13 +++++++ .../quickFix/invokeHandle/beforeSetter.java | 13 +++++++ .../quickFix/invokeHandle/beforeSetter2.java | 13 +++++++ .../invokeHandle/beforeStaticGetter.java | 13 +++++++ .../invokeHandle/beforeStaticGetter2.java | 13 +++++++ .../invokeHandle/beforeStaticMethod.java | 15 ++++++++ .../invokeHandle/beforeStaticMethod2.java | 15 ++++++++ .../invokeHandle/beforeStaticMethod3.java | 15 ++++++++ .../invokeHandle/beforeStaticMethod4.java | 13 +++++++ .../invokeHandle/beforeStaticSetter.java | 13 +++++++ .../invokeHandle/beforeStaticSetter2.java | 13 +++++++ .../invokeHandle/beforeStaticVarHandle.java | 13 +++++++ .../invokeHandle/beforeStaticVarHandle2.java | 13 +++++++ .../invokeHandle/beforeVarHandle.java | 13 +++++++ .../invokeHandle/beforeVarHandle2.java | 13 +++++++ .../invokeHandle/beforeVirtualMethod.java | 15 ++++++++ .../invokeHandle/beforeVirtualMethod2.java | 15 ++++++++ .../invokeHandle/beforeVirtualMethod3.java | 15 ++++++++ .../invokeHandle/beforeVirtualMethod4.java | 13 +++++++ .../JavaLangInvokeHandleSignatureFixTest.kt | 37 +++++++++++++++++++ 57 files changed, 807 insertions(+) create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGetter.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGetter2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterSetter.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterSetter2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticGetter.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticGetter2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticSetter.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticSetter2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticVarHandle.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticVarHandle2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVarHandle.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVarHandle2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGetter.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGetter2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeSetter.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeSetter2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticGetter.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticGetter2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod4.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticSetter.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticSetter2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticVarHandle.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticVarHandle2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVarHandle.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVarHandle2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod2.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod3.java create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod4.java create mode 100644 java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/JavaLangInvokeHandleSignatureFixTest.kt diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor.java new file mode 100644 index 000000000000..e772511faa14 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor.java @@ -0,0 +1,14 @@ +// "Use constructor 'Test(int)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findConstructor(Test.class, MethodType.methodType(void.class, int.class)); + } +} + +class Test { + public Test() {} + public Test(int a) {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor2.java new file mode 100644 index 000000000000..c1ac2a4bd703 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor2.java @@ -0,0 +1,13 @@ +// "Use constructor 'Test(int)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findConstructor(Test.class, MethodType.methodType(void.class, int.class)); + } +} + +class Test { + public Test(int a) {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor3.java new file mode 100644 index 000000000000..e4b63f3d6009 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor3.java @@ -0,0 +1,12 @@ +// "Use constructor 'Test()'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findConstructor(Test.class, MethodType.methodType(void.class)); + } +} + +class Test { +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor4.java new file mode 100644 index 000000000000..2cae4911856d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterConstructor4.java @@ -0,0 +1,14 @@ +// "Use constructor 'Test()'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findConstructor(Test.class, MethodType.methodType(void.class)); + } +} + +class Test { + public Test() {} + public Test(int a) {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod.java new file mode 100644 index 000000000000..67b1cfc14887 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.Object method(java.lang.Object)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(Object.class, Object.class)); + } +} + +class Test { + public T method(T a) {return null;} + public T method(T a, T... b) {return null;} + public T method(T a, String b) {return null;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod2.java new file mode 100644 index 000000000000..eef2bf8fbfa2 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod2.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.Object method(java.lang.Object, java.lang.Object[])'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(Object.class, Object.class, Object[].class)); + } +} + +class Test { + public T method(T a) {return null;} + public T method(T a, T... b) {return null;} + public T method(T a, String b) {return null;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod3.java new file mode 100644 index 000000000000..38e16ee62356 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod3.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.Object method(java.lang.Object, java.lang.String)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(Object.class, Object.class, String.class)); + } +} + +class Test { + public T method(T a) {return null;} + public T method(T a, T... b) {return null;} + public T method(T a, String b) {return null;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod4.java new file mode 100644 index 000000000000..67b1cfc14887 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGenericMethod4.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.Object method(java.lang.Object)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(Object.class, Object.class)); + } +} + +class Test { + public T method(T a) {return null;} + public T method(T a, T... b) {return null;} + public T method(T a, String b) {return null;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGetter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGetter.java new file mode 100644 index 000000000000..c833597dc930 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGetter.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findGetter(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGetter2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGetter2.java new file mode 100644 index 000000000000..b5a8fe3bcbc4 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterGetter2.java @@ -0,0 +1,13 @@ +// "Replace with 'findGetter'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findGetter(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterSetter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterSetter.java new file mode 100644 index 000000000000..b97db4b5861b --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterSetter.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findSetter(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterSetter2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterSetter2.java new file mode 100644 index 000000000000..be6c2aaed23a --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterSetter2.java @@ -0,0 +1,13 @@ +// "Replace with 'findSetter'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findSetter(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticGetter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticGetter.java new file mode 100644 index 000000000000..750a561b76c4 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticGetter.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticGetter(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticGetter2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticGetter2.java new file mode 100644 index 000000000000..73af78fbd7fd --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticGetter2.java @@ -0,0 +1,13 @@ +// "Replace with 'findStaticGetter'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticGetter(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod.java new file mode 100644 index 000000000000..a00bc651e0a4 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod.java @@ -0,0 +1,15 @@ +// "Use method 'void method()'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findStatic(Test.class, "method", MethodType.methodType(void.class)); + } +} + +class Test { + public static void method() {} + public static String method(String a) {return a;} + public static String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod2.java new file mode 100644 index 000000000000..bed6862726d5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod2.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.String method(java.lang.String)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findStatic(Test.class, "method", MethodType.methodType(String.class, String.class)); + } +} + +class Test { + public static void method() {} + public static String method(String a) {return a;} + public static String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod3.java new file mode 100644 index 000000000000..f50e2b823a82 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod3.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.String method(java.lang.String, java.lang.String[])'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findStatic(Test.class, "method", MethodType.methodType(String.class, String.class, String[].class)); + } +} + +class Test { + public static void method() {} + public static String method(String a) {return a;} + public static String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod4.java new file mode 100644 index 000000000000..15e5f57cc787 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticMethod4.java @@ -0,0 +1,13 @@ +// "Replace with 'findStatic'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findStatic(Test.class, "method", MethodType.methodType(void.class)); + } +} + +class Test { + public static void method() {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticSetter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticSetter.java new file mode 100644 index 000000000000..764227123315 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticSetter.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticSetter(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticSetter2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticSetter2.java new file mode 100644 index 000000000000..c6444b4738e8 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticSetter2.java @@ -0,0 +1,13 @@ +// "Replace with 'findStaticSetter'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticSetter(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticVarHandle.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticVarHandle.java new file mode 100644 index 000000000000..2985d663c3ad --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticVarHandle.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticVarHandle(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticVarHandle2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticVarHandle2.java new file mode 100644 index 000000000000..cb4b4760aa0e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterStaticVarHandle2.java @@ -0,0 +1,13 @@ +// "Replace with 'findStaticVarHandle'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticVarHandle(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVarHandle.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVarHandle.java new file mode 100644 index 000000000000..277a2637c003 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVarHandle.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findVarHandle(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVarHandle2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVarHandle2.java new file mode 100644 index 000000000000..250df9ac7896 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVarHandle2.java @@ -0,0 +1,13 @@ +// "Replace with 'findVarHandle'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findVarHandle(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod.java new file mode 100644 index 000000000000..5b8ddfe796c1 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod.java @@ -0,0 +1,15 @@ +// "Use method 'void method()'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findVirtual(Test.class, "method", MethodType.methodType(void.class)); + } +} + +class Test { + public void method() {} + public String method(String a) {return a;} + public String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod2.java new file mode 100644 index 000000000000..dd401969beb1 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod2.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.String method(java.lang.String)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(String.class, String.class)); + } +} + +class Test { + public void method() {} + public String method(String a) {return a;} + public String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod3.java new file mode 100644 index 000000000000..df7070b6ef63 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod3.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.String method(java.lang.String, java.lang.String[])'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(String.class, String.class, String[].class)); + } +} + +class Test { + public void method() {} + public String method(String a) {return a;} + public String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod4.java new file mode 100644 index 000000000000..79427529951f --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/afterVirtualMethod4.java @@ -0,0 +1,13 @@ +// "Replace with 'findVirtual'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findVirtual(Test.class, "method", MethodType.methodType(void.class)); + } +} + +class Test { + public void method() {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor.java new file mode 100644 index 000000000000..137079da43dd --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor.java @@ -0,0 +1,14 @@ +// "Use constructor 'Test(int)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findConstructor(Test.class, MethodType.methodType(void.class, String.class)); + } +} + +class Test { + public Test() {} + public Test(int a) {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor2.java new file mode 100644 index 000000000000..3f27f9206e08 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor2.java @@ -0,0 +1,13 @@ +// "Use constructor 'Test(int)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findConstructor(Test.class, MethodType.methodType(void.class)); + } +} + +class Test { + public Test(int a) {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor3.java new file mode 100644 index 000000000000..5b30e1db0205 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor3.java @@ -0,0 +1,12 @@ +// "Use constructor 'Test()'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findConstructor(Test.class, MethodType.methodType(void.class, String.class)); + } +} + +class Test { +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor4.java new file mode 100644 index 000000000000..7f09bd517dbd --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeConstructor4.java @@ -0,0 +1,14 @@ +// "Use constructor 'Test()'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findConstructor(Test.class, MethodType.methodType(void.class, String.class)); + } +} + +class Test { + public Test() {} + public Test(int a) {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod.java new file mode 100644 index 000000000000..f5847b0b9bed --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.Object method(java.lang.Object)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.genericMethodType(2)); + } +} + +class Test { + public T method(T a) {return null;} + public T method(T a, T... b) {return null;} + public T method(T a, String b) {return null;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod2.java new file mode 100644 index 000000000000..bd8c7af0bf28 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod2.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.Object method(java.lang.Object, java.lang.Object[])'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.genericMethodType(2)); + } +} + +class Test { + public T method(T a) {return null;} + public T method(T a, T... b) {return null;} + public T method(T a, String b) {return null;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod3.java new file mode 100644 index 000000000000..f7059c9047e8 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod3.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.Object method(java.lang.Object, java.lang.String)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.genericMethodType(2)); + } +} + +class Test { + public T method(T a) {return null;} + public T method(T a, T... b) {return null;} + public T method(T a, String b) {return null;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod4.java new file mode 100644 index 000000000000..3b0353b09829 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGenericMethod4.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.Object method(java.lang.Object)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.genericMethodType(0, true)); + } +} + +class Test { + public T method(T a) {return null;} + public T method(T a, T... b) {return null;} + public T method(T a, String b) {return null;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGetter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGetter.java new file mode 100644 index 000000000000..2d24a0539a2d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGetter.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findGetter(Test.class, "myInt", String.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGetter2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGetter2.java new file mode 100644 index 000000000000..c6cbcccb601b --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeGetter2.java @@ -0,0 +1,13 @@ +// "Replace with 'findGetter'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticGetter(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeSetter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeSetter.java new file mode 100644 index 000000000000..965f1f9b9d75 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeSetter.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findSetter(Test.class, "myInt", String.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeSetter2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeSetter2.java new file mode 100644 index 000000000000..5238d673f479 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeSetter2.java @@ -0,0 +1,13 @@ +// "Replace with 'findSetter'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticSetter(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticGetter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticGetter.java new file mode 100644 index 000000000000..11e354554480 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticGetter.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticGetter(Test.class, "ourInt", String.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticGetter2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticGetter2.java new file mode 100644 index 000000000000..de1b5c994248 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticGetter2.java @@ -0,0 +1,13 @@ +// "Replace with 'findStaticGetter'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findGetter(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod.java new file mode 100644 index 000000000000..0c16ec81ae63 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod.java @@ -0,0 +1,15 @@ +// "Use method 'void method()'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findStatic(Test.class, "method", MethodType.methodType(String.class)); + } +} + +class Test { + public static void method() {} + public static String method(String a) {return a;} + public static String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod2.java new file mode 100644 index 000000000000..df3e535c4fbb --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod2.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.String method(java.lang.String)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findStatic(Test.class, "method", MethodType.methodType(void.class, void.class)); + } +} + +class Test { + public static void method() {} + public static String method(String a) {return a;} + public static String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod3.java new file mode 100644 index 000000000000..53d7e0bf2f8f --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod3.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.String method(java.lang.String, java.lang.String[])'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findStatic(Test.class, "method", MethodType.methodType(String.class)); + } +} + +class Test { + public static void method() {} + public static String method(String a) {return a;} + public static String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod4.java new file mode 100644 index 000000000000..7270b7a2e14d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticMethod4.java @@ -0,0 +1,13 @@ +// "Replace with 'findStatic'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(void.class)); + } +} + +class Test { + public static void method() {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticSetter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticSetter.java new file mode 100644 index 000000000000..3d4f99d964e0 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticSetter.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticSetter(Test.class, "ourInt", String.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticSetter2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticSetter2.java new file mode 100644 index 000000000000..e1b3c954f8df --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticSetter2.java @@ -0,0 +1,13 @@ +// "Replace with 'findStaticSetter'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findSetter(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticVarHandle.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticVarHandle.java new file mode 100644 index 000000000000..5f29b5bf2ff2 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticVarHandle.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticVarHandle(Test.class, "ourInt", boolean.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticVarHandle2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticVarHandle2.java new file mode 100644 index 000000000000..88aa9eaaa244 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeStaticVarHandle2.java @@ -0,0 +1,13 @@ +// "Replace with 'findStaticVarHandle'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findVarHandle(Test.class, "ourInt", int.class); + } +} + +class Test { + public static int ourInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVarHandle.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVarHandle.java new file mode 100644 index 000000000000..c8888c062fa5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVarHandle.java @@ -0,0 +1,13 @@ +// "Change type to 'int'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findVarHandle(Test.class, "myInt", String.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVarHandle2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVarHandle2.java new file mode 100644 index 000000000000..aef0c0997077 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVarHandle2.java @@ -0,0 +1,13 @@ +// "Replace with 'findVarHandle'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStaticVarHandle(Test.class, "myInt", int.class); + } +} + +class Test { + public int myInt; +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod.java new file mode 100644 index 000000000000..3a6aa34c1817 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod.java @@ -0,0 +1,15 @@ +// "Use method 'void method()'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findVirtual(Test.class, "method", MethodType.methodType(String.class)); + } +} + +class Test { + public void method() {} + public String method(String a) {return a;} + public String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod2.java new file mode 100644 index 000000000000..aa3c22e0b76f --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod2.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.String method(java.lang.String)'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(void.class, void.class)); + } +} + +class Test { + public void method() {} + public String method(String a) {return a;} + public String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod3.java new file mode 100644 index 000000000000..f16fa12376c5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod3.java @@ -0,0 +1,15 @@ +// "Use method 'java.lang.String method(java.lang.String, java.lang.String[])'" "true" +import java.lang.invoke.*; + +class Main { + void foo() throws Exception { + MethodHandles.Lookup l = MethodHandles.lookup(); + l.findVirtual(Test.class, "method", MethodType.methodType(String.class)); + } +} + +class Test { + public void method() {} + public String method(String a) {return a;} + public String method(String a, String... b) {return a;} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod4.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod4.java new file mode 100644 index 000000000000..d36facdcc371 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle/beforeVirtualMethod4.java @@ -0,0 +1,13 @@ +// "Replace with 'findVirtual'" "true" +import java.lang.invoke.*; + +public class Main { + void foo() throws Throwable { + MethodHandles.Lookup lookup = MethodHandles.lookup(); + lookup.findStatic(Test.class, "method", MethodType.methodType(void.class)); + } +} + +class Test { + public void method() {} +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/JavaLangInvokeHandleSignatureFixTest.kt b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/JavaLangInvokeHandleSignatureFixTest.kt new file mode 100644 index 000000000000..aa301327474f --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/JavaLangInvokeHandleSignatureFixTest.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2000-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.codeInsight.daemon.quickFix + +import com.intellij.codeInspection.reflectiveAccess.JavaLangInvokeHandleSignatureInspection +import com.intellij.testFramework.LightProjectDescriptor +import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase + +/** + * @author Pavel.Dolgov + */ +class JavaLangInvokeHandleSignatureFixTest : LightQuickFixParameterizedTestCase() { + + override fun getProjectDescriptor(): LightProjectDescriptor = LightCodeInsightFixtureTestCase.JAVA_9 + + override fun setUp() { + super.setUp() + enableInspectionTool(JavaLangInvokeHandleSignatureInspection()) + } + + fun test() = doAllTests() + + override fun getBasePath() = "/codeInsight/daemonCodeAnalyzer/quickFix/invokeHandle" +}