new overload resolution: integrate isPotentiallyCompatible in isApplicable checks

2026-08-26 00:11:26 +07:00 · 2014-11-26 17:42:30 +01:00
parent 68cc2ec0a2
commit 145f701bc1
16 changed files with 140 additions and 139 deletions
@@ -20,7 +20,7 @@ public class Test<A, B extends Number>  {
    public static void main(String[] args) {
        Inner<Number, Double> inn = new Inner<>();
        inn.m8<error descr="Ambiguous method call: both 'Inner.m8(IO<? extends Number>)' and 'Inner.m8(IN<? extends Double>)' match">(p -> 1.0)</error>;
-        new Test<Number, Integer>().foo<error descr="Ambiguous method call: both 'Test.foo(IO<? extends Number>)' and 'Test.foo(IN<? extends Integer>)' match">(p -> 1.0)</error>;
+        new Test<Number, Integer>().foo<error descr="Cannot resolve method 'foo(<lambda expression>)'">(p -> 1.0)</error>;

    }
 }
@@ -1,7 +1,7 @@
 class Demo {

    public void f1() {
-        f2(2, <error descr="Target type of a lambda conversion must be an interface">input -> input</error>);
+        f2<error descr="Cannot resolve method 'f2(int, <lambda expression>)'">(2, input -> input)</error>;
    }

    public void f2() {
@@ -25,7 +25,7 @@ class ReturnTypeIncompatibility {
    }

    public static void main(String[] args) {
-        call<error descr="Ambiguous method call: both 'ReturnTypeIncompatibility.call(I1<Integer>)' and 'ReturnTypeIncompatibility.call(I2<P>)' match">(i-> {return i;})</error>;
+        call<error descr="Cannot resolve method 'call(<lambda expression>)'">(i-> {return i;})</error>;
    }
 }

@@ -57,7 +57,7 @@ class ReturnTypeCompatibility {
    }

    public static void main(String[] args) {
-        call<error descr="Ambiguous method call: both 'ReturnTypeCompatibility.call(I1<Number>)' and 'ReturnTypeCompatibility.call(I2<String>)' match">(i-> {return i;})</error>;
+        call<error descr="Cannot resolve method 'call(<lambda expression>)'">(i-> {return i;})</error>;
    }
 }

@@ -21,9 +21,9 @@ class Test {
    }

    void foo(Foo<String> as, final Foo<Character> ac) {
-        boolean b1 = as.forAll(s -> ac.forAll<error descr="Ambiguous method call: both 'Foo.forAll(I<Character, Boolean>)' and 'Foo.forAll(II<Character, String>)' match">(c -> false)</error>);
-        String s1 = as.forAll(s -> ac.forAll<error descr="Ambiguous method call: both 'Foo.forAll(I<Character, Boolean>)' and 'Foo.forAll(II<Character, String>)' match">(c -> "")</error>);
-        boolean b2 = as.forAll(s -> ac.forAll<error descr="Ambiguous method call: both 'Foo.forAll(I<Character, Boolean>)' and 'Foo.forAll(II<Character, String>)' match">(c -> "")</error>);
+        boolean b1 = as.forAll(s -> ac.forAll<error descr="Cannot resolve method 'forAll(<lambda expression>)'">(c -> false)</error>);
+        String s1 = as.forAll(s -> ac.forAll<error descr="Cannot resolve method 'forAll(<lambda expression>)'">(c -> "")</error>);
+        boolean b2 = as.forAll(s -> ac.forAll<error descr="Cannot resolve method 'forAll(<lambda expression>)'">(c -> "")</error>);
        String s2 = as.forAll2(s -> ac.forAll2(<error descr="Incompatible return type boolean in lambda expression">c -> false</error>));
        boolean b3 = as.forAll((I<String, Boolean>)s -> ac.forAll((I<Character, Boolean>)<error descr="Incompatible return type String in lambda expression">c -> ""</error>));
        String s3 = as.forAll((II<String, String>)s -> ac.forAll((II<Character, String>)<error descr="Incompatible return type boolean in lambda expression">c -> false</error>));
@@ -14,7 +14,7 @@ class Test {
  }

  void fooBar(IntStream1 instr){
-    Supplier<Stream<Integer>> si = () -> instr.map ((i) -> (( <error descr="Operator '%' cannot be applied to '<lambda parameter>', 'int'">i % 2</error>) == 0) ? i : <error descr="Incompatible types. Found: '<lambda parameter>', required: '<lambda parameter>'">-i</error>).boxed();
+    Supplier<Stream<Integer>> si = () -> instr.map ((i) -> (( <error descr="Operator '%' cannot be applied to '<lambda parameter>', 'int'">i % 2</error>) == 0) ? i : -i).boxed();
    System.out.println(si);
    Supplier<Stream<Integer>> si1 = () -> instr.map <error descr="Ambiguous method call: both 'IntStream1.map(IntFunction<Integer>)' and 'IntStream1.map(IntUnaryOperator)' match">(null)</error>.boxed();
    System.out.println(si1);
@@ -12,6 +12,6 @@ abstract class PertinentToApplicabilityOfExplicitlyTypedLambdaTest {
  abstract void foo(B b);

  {
-    foo<error descr="Ambiguous method call: both 'PertinentToApplicabilityOfExplicitlyTypedLambdaTest.foo(A)' and 'PertinentToApplicabilityOfExplicitlyTypedLambdaTest.foo(B)' match">(x -> y -> 42)</error>;
+    foo<error descr="Cannot resolve method 'foo(<lambda expression>)'">(x -> y -> 42)</error>;
  }
 }
@@ -14,10 +14,10 @@ abstract class Test {
    foo(x -> {
      return x += 1;
    });
-    foo(x -> <error descr="Incompatible types. Found: 'int', required: '<lambda parameter>'">x += 1</error>);
+    foo<error descr="Ambiguous method call: both 'Test.foo(A)' and 'Test.foo(B)' match">(x -> x += 1)</error>;
    foo(x -> 1);
    foo(x -> <error descr="Operator '!' cannot be applied to 'int'">!x</error>);
-    foo(x -> <error descr="Operator '++' cannot be applied to '<lambda parameter>'">++x</error>);
+    foo<error descr="Ambiguous method call: both 'Test.foo(A)' and 'Test.foo(B)' match">(x -> ++x)</error>;
    foo(x -> o instanceof String ? 1 : 0);
  }
 }
@@ -26,9 +26,9 @@ class Foo {
      System.out.println(s);
    });

-    <error descr="Cannot resolve method 'foo(<lambda expression>)'">foo</error>((String p, String k) -> {
+    foo<error descr="Cannot resolve method 'foo(<lambda expression>)'">((String p, String k) -> {
      System.out.println(p);
-    });
+    })</error>;
  }
 }

@@ -62,7 +62,7 @@ class WithTypeParams {
        System.out.println(p);
      });
  
-      <error descr="Cannot resolve method 'foo(<lambda expression>)'">foo</error>((int k) -> {System.out.println(k);});
+      foo<error descr="Cannot resolve method 'foo(<lambda expression>)'">((int k) -> {System.out.println(k);})</error>;
    }
  }
 }