lambda: redundant lambda param types

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterAssignment.java

@@ -0,0 +1,6 @@
+// "Remove redundant types" "true"
+class Test {
+  {
+    Comparable<String> r = o-> 1;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterCallWithTypeArgs.java

@@ -0,0 +1,16 @@
+// "Remove redundant types" "true"
+class Test2 {
+    class Y<T>{
+        T t;
+    }
+
+    interface I<X> {
+        X foo(Y<X> list);
+    }
+
+    static <T> I<T> bar(I<T> i){return i;}
+
+    {
+        Test2.<String>bar(y-> y.t);
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/afterInferredFromOtherArgs.java

@@ -0,0 +1,15 @@
+// "Remove redundant types" "true"
+class ReturnTypeCompatibility {
+
+    interface I1<L> {
+        L m(L x);
+    }
+
+    static <P> void call(P p, I1<P> i2) {
+        i2.m(null);
+    }
+
+    public static void main(String[] args) {
+        call("",  i-> "");
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignment.java

@@ -0,0 +1,6 @@
+// "Remove redundant types" "true"
+class Test {
+  {
+    Comparable<String> r = (St<caret>ring o) -> 1;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignmentNoParams.java

@@ -0,0 +1,6 @@
+// "Remove redundant types" "false"
+class Test {
+  {
+    Runnable r = (<caret>) -> {};
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeAssignmentNoTypes.java

@@ -0,0 +1,6 @@
+// "Remove redundant types" "false"
+class Test {
+  {
+    Comparable<String> r = <caret>o -> 1;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallNoTypeArgs.java

@@ -0,0 +1,16 @@
+// "Remove redundant types" "false"
+class Test2 {
+    class Y<T>{
+        T t;
+    }
+
+    interface I<X> {
+        X foo(Y<X> list);
+    }
+
+    static <T> I<T> bar(I<T> i){return i;}
+
+    {
+        Test2.bar((Y<St<caret>ring> y) -> y.t);
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallNoTypeArgs1.java

@@ -0,0 +1,13 @@
+// "Remove redundant types" "false"
+class NoInferenceResult {
+    interface I<A, B>  {
+      B foo(A a);
+    }
+
+    <A, B> I<A, B> m(I<A, B>  f) { return null; }
+
+    void test() {
+        m((Stri<caret>ng s1) -> s1.length());
+        m((String s1) -> s1);
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeCallWithTypeArgs.java

@@ -0,0 +1,16 @@
+// "Remove redundant types" "true"
+class Test2 {
+    class Y<T>{
+        T t;
+    }
+
+    interface I<X> {
+        X foo(Y<X> list);
+    }
+
+    static <T> I<T> bar(I<T> i){return i;}
+
+    {
+        Test2.<String>bar((Y<St<caret>ring> y) -> y.t);
+    }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/redundantLambdaParameterType/beforeInferredFromOtherArgs.java

@@ -0,0 +1,15 @@
+// "Remove redundant types" "true"
+class ReturnTypeCompatibility {
+
+    interface I1<L> {
+        L m(L x);
+    }
+
+    static <P> void call(P p, I1<P> i2) {
+        i2.m(null);
+    }
+
+    public static void main(String[] args) {
+        call("",  (Str<caret>ing  i) -> "");
+    }
+}