Java: Improved inspection "MethodHandle/VarHandle type mismatch" - show candidates for replacement of method/constructor in a separate pop-up menu (IDEA-167318)

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterConstructor.java

@@ -0,0 +1,13 @@
+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) {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterConstructor2.java

@@ -0,0 +1,12 @@
+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) {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterConstructor3.java

@@ -0,0 +1,11 @@
+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 {
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterConstructor4.java

@@ -0,0 +1,13 @@
+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) {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterGenericMethod.java

@@ -0,0 +1,14 @@
+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> T method(T a) {return null;}
+  public <T> T method(T a, T... b) {return null;}
+  public <T> T method(T a, String b) {return null;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterGenericMethod2.java

@@ -0,0 +1,14 @@
+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> T method(T a) {return null;}
+  public <T> T method(T a, T... b) {return null;}
+  public <T> T method(T a, String b) {return null;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterGenericMethod3.java

@@ -0,0 +1,14 @@
+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> T method(T a) {return null;}
+  public <T> T method(T a, T... b) {return null;}
+  public <T> T method(T a, String b) {return null;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterGenericMethod4.java

@@ -0,0 +1,14 @@
+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> T method(T a) {return null;}
+  public <T> T method(T a, T... b) {return null;}
+  public <T> T method(T a, String b) {return null;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterStaticMethod.java

@@ -0,0 +1,14 @@
+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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterStaticMethod2.java

@@ -0,0 +1,14 @@
+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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterStaticMethod3.java

@@ -0,0 +1,14 @@
+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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterStaticMethod4.java

@@ -0,0 +1,12 @@
+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() {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterVirtualMethod.java

@@ -0,0 +1,14 @@
+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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterVirtualMethod2.java

@@ -0,0 +1,14 @@
+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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterVirtualMethod3.java

@@ -0,0 +1,14 @@
+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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/afterVirtualMethod4.java

@@ -0,0 +1,12 @@
+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() {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeConstructor.java

@@ -0,0 +1,13 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findConstructor(Test.class, <caret>MethodType.methodType(void.class, String.class));
+  }
+}
+
+class Test {
+  public Test() {}
+  public Test(int a) {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeConstructor2.java

@@ -0,0 +1,12 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findConstructor(Test.class, <caret>MethodType.methodType(void.class));
+  }
+}
+
+class Test {
+  public Test(int a) {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeConstructor3.java

@@ -0,0 +1,11 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findConstructor(Test.class, <caret>MethodType.methodType(void.class, String.class));
+  }
+}
+
+class Test {
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeConstructor4.java

@@ -0,0 +1,13 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findConstructor(Test.class, <caret>MethodType.methodType(void.class, String.class));
+  }
+}
+
+class Test {
+  public Test() {}
+  public Test(int a) {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeGenericMethod.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findVirtual(Test.class, "method", <caret>MethodType.genericMethodType(2));
+  }
+}
+
+class Test {
+  public <T> T method(T a) {return null;}
+  public <T> T method(T a, T... b) {return null;}
+  public <T> T method(T a, String b) {return null;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeGenericMethod2.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findVirtual(Test.class, "method", <caret>MethodType.genericMethodType(2));
+  }
+}
+
+class Test {
+  public <T> T method(T a) {return null;}
+  public <T> T method(T a, T... b) {return null;}
+  public <T> T method(T a, String b) {return null;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeGenericMethod3.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findVirtual(Test.class, "method", <caret>MethodType.genericMethodType(2));
+  }
+}
+
+class Test {
+  public <T> T method(T a) {return null;}
+  public <T> T method(T a, T... b) {return null;}
+  public <T> T method(T a, String b) {return null;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeGenericMethod4.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findVirtual(Test.class, "method", <caret>MethodType.genericMethodType(0, true));
+  }
+}
+
+class Test {
+  public <T> T method(T a) {return null;}
+  public <T> T method(T a, T... b) {return null;}
+  public <T> T method(T a, String b) {return null;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeStaticMethod.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findStatic(Test.class, "method", <caret>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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeStaticMethod2.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findStatic(Test.class, "method", <caret>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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeStaticMethod3.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findStatic(Test.class, "method", <caret>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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeStaticMethod4.java

@@ -0,0 +1,12 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.<caret>findVirtual(Test.class, "method", MethodType.methodType(void.class));
+  }
+}
+
+class Test {
+  public static void method() {}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeVirtualMethod.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+public class Main {
+  void foo() throws Throwable {
+    MethodHandles.Lookup lookup = MethodHandles.lookup();
+    lookup.findVirtual(Test.class, "method", <caret>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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeVirtualMethod2.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findVirtual(Test.class, "method", <caret>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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeVirtualMethod3.java

@@ -0,0 +1,14 @@
+import java.lang.invoke.*;
+
+class Main {
+  void foo() throws Exception {
+    MethodHandles.Lookup l = MethodHandles.lookup();
+    l.findVirtual(Test.class, "method", <caret>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;}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/methodHandle/beforeVirtualMethod4.java

@@ -0,0 +1,12 @@
+import java.lang.invoke.*;
+
+public class Main {
+  void foo() throws Throwable {
+    MethodHandles.Lookup lookup = MethodHandles.lookup();
+    lookup.<caret>findStatic(Test.class, "method", MethodType.methodType(void.class));
+  }
+}
+
+class Test {
+  public void method() {}
+}