lambda: infer from return type; cyclic inference stop

2026-08-25 14:25:04 +07:00 · 2012-08-13 11:29:40 +04:00
parent bff2c6d55c
commit 5ba5425a54
22 changed files with 642 additions and 207 deletions
@@ -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>;
  }
 }
@@ -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;
    }
 }
-
-
-
-
-
-
@@ -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());
+    }
+    
+}
@@ -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() {
@@ -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>); 
    }
 }
@@ -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>);
    }
 }

@@ -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>
    }
 }
@@ -0,0 +1,48 @@
+public class NotAFIT {
+  static class First {
+    static interface A<T> {
+      void foo1();
+      void foo2();
+    }
+    static <T> void foo(A<T> a) {
+    }
+
+    void bar() {
+        foo(<error descr="Multiple non-overriding abstract methods found">() ->{}</error>);
+    }
+  }
+
+  static class WithInheritance {
+    static interface A<T> {
+      void foo1();
+    }
+
+    static interface B<M> extends A<M> {
+      void foo2();
+    }
+
+    static <T> void foo(B<T> a) {
+    }
+
+    void bar() {
+      foo(<error descr="Multiple non-overriding abstract methods found">()->{}</error>);
+    }
+  }
+
+  static class WithInheritanceOverrideSameMethod {
+    static interface A<T> {
+      void foo1();
+    }
+
+    static interface B<M> extends A<M> {
+      void foo1();
+    }
+
+    static <T> void foo(B<T> a) {
+    }
+
+    void bar() {
+      foo(()->{});
+    }
+  }
+}
@@ -0,0 +1,20 @@
+class NoLambda {
+    interface I<T> {
+        void f(T t);
+    }
+
+    <Z> void bar(I<Z> iz) {
+    }
+
+    void bazz() {
+        bar(null);
+        bar(<error descr="Cyclic inference">(z)-> {System.out.println();}</error>);
+    }
+  
+    static <T> T id(T i2) {return i2;}
+
+    {
+       id(<error descr="Cyclic inference">() -> {System.out.println("hi");}</error>);
+       NoLambda.<Runnable>id(() -> {System.out.println("hi");});
+    }
+}
@@ -30,6 +30,6 @@ class ReturnTypeCompatibility {

    public static void main(String[] args) {
        call((String i)->{ return i;});
-        call<error descr="'call(ReturnTypeCompatibility.I1<java.lang.Object>)' in 'ReturnTypeCompatibility' cannot be applied to '(<lambda expression>)'">((int i)->{ return i;})</error>;
+        call<error descr="'call(ReturnTypeCompatibility.I1<java.lang.Integer>)' in 'ReturnTypeCompatibility' cannot be applied to '(<lambda expression>)'">((int i)->{ return i;})</error>;
    }
 }