lambda: infer from return type; cyclic inference stop

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/Ambiguity1.java

@@ -12,6 +12,6 @@ class Ambiguity1 {
   static <T> void m(I2<T> i2) {}
 
   {
-    m<error descr="Ambiguous method call: both 'Ambiguity1.m(I1)' and 'Ambiguity1.m(I2<Object>)' match">(()->{throw new AssertionError();})</error>;
+    m<error descr="Ambiguous method call: both 'Ambiguity1.m(I1)' and 'Ambiguity1.m(I2<T>)' match">(()->{throw new AssertionError();})</error>;
   }
 }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/InferenceFromArgs.java

@@ -11,19 +11,21 @@ interface SameArgsI<T> {
 
 class InferenceFromArgs {
 
-    private static <E> void bar(A<? extends E> a, I<? super E, Integer> i) { }
+    private static <E> void bar(A<E> a, I<E, Integer> i) { }
+    private static <E> void bazz(I<? super E, Integer> i) { }
 
     void foo(B<Integer> b) {
-        bar(b, (k, v) -> {int i = k; int j = v; return Math.max(i, j);});
+         bar(null, <error descr="Cyclic inference">(k, v) -> v</error>);
+         bar(null, null);
+         bar(b, (k, v) ->  {return v;});
+         bar(b, (k, v) -> {<error descr="Incompatible types. Found: 'java.lang.Integer', required: 'java.lang.String'">String i = k;</error> return v;});
+         bar(b, (k, v) -> {Integer  i = k; return v;});
+
+         bazz(<error descr="Cyclic inference">(k, v) -> v</error>);
+         bazz((k, v) -> {<error descr="Incompatible types. Found: 'E', required: 'int'">int i = k;</error> return v;});
     }
 
     public static <T> SameArgsI<T> max() {
         return (a, b) -> b;
     }
 }
-
-
-
-
-
-

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/InferenceOnMethodCallSite.java

@@ -0,0 +1,17 @@
+import java.util.*;
+interface In<X> {
+    List<X> f();
+}
+
+class InferenceOnMethodCallSite {
+    <Z> void m(In<Z> i, In<Z> ii) { }
+    <Z> void m(In<Z> s) { }
+
+    {
+        m(<error descr="Cyclic inference">( ) -> Collections.emptyList()</error>);
+        m((In<String>)() -> Collections.emptyList(), () ->  new ArrayList<String>());
+        m(() ->Collections.<String>emptyList(), () -> new ArrayList<String>());
+        m(() -> Collections.<String>emptyList());
+    }
+    
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/LambdaContext.java

@@ -6,8 +6,8 @@ class Test {
     void foo(Object x) {}
 
     void bar() {
-        foo(<error descr="Operator '!' cannot be applied to '<lambda expression>'">!(int x)-> {}</error>);
-        foo(<error descr="Lambda expression is not expected here">(int x)-> { } instanceof Object</error> );
+        foo(!<error descr="Lambda expression not expected here">(int x)-> {}</error>);
+        foo(<error descr="Lambda expression not expected here">(int x)-> { }</error> instanceof Object );
     }
 
     I bazz() {

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/NoInferenceResult.java

@@ -7,11 +7,11 @@ class NoInferenceResult {
     <T> void m1(T t) { }
 
     void test() {
-        m<error descr="'m(I<java.lang.Object,java.lang.Object>)' in 'NoInferenceResult' cannot be applied to '(<lambda expression>)'">((String s1) ->  (String s2) ->  s1 + s2)</error>;
+        m((String s1) ->  <error descr="Cyclic inference">(String s2) ->  s1 + s2</error>);
 
         m((String s1) -> s1.length());
         m((String s1) -> s1);
 
-        m1<error descr="'m1(java.lang.Object)' in 'NoInferenceResult' cannot be applied to '(<lambda expression>)'">(() -> { })</error>; 
+        m1(<error descr="Cyclic inference">() -> { }</error>); 
     }
 }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility.java

@@ -57,7 +57,7 @@ class ReturnTypeCompatibility {
     }
 
     public static void main(String[] args) {
-        <error descr="Cannot resolve method 'call(<lambda expression>)'">call</error>(i-> {return i;});
+        call(<error descr="Cyclic inference">i-> {return i;}</error>);
     }
 }
 

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/TypeArgsConsistency.java

@@ -12,6 +12,6 @@ class TypeArgsConsistency {
       I<Integer> i1 = (i, j) -> i + j;
       foo((i, j) -> i + j);
       I<Integer> i2 = bar((i, j) -> i + j);
-      I<Integer> i3 = bar<error descr="'bar(TypeArgsConsistency.I<java.lang.Integer>)' in 'TypeArgsConsistency' cannot be applied to '(<lambda expression>)'">((i, j) -> "" + i + j)</error>;
+      <error descr="Incompatible types. Found: 'TypeArgsConsistency.I<java.lang.String>', required: 'TypeArgsConsistency.I<java.lang.Integer>'">I<Integer> i3 = bar((i, j) -> "" + i + j);</error>
     }
 }