lambda: highlight containing method ambiguity on method name: this avoids lots of...
authorAnna Kozlova <anna.kozlova@jetbrains.com>
Thu, 18 Jun 2015 13:22:27 +0000 (16:22 +0300)
committerAnna Kozlova <anna.kozlova@jetbrains.com>
Thu, 18 Jun 2015 14:54:23 +0000 (17:54 +0300)
22 files changed:
java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java
java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityRawGenerics.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution1.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguitySpecificReturn.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityVarargs.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility1.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/DifferentParamsLength.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/IncompleteMethodInInterface.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/JDK8034223.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/RelatedSAMErasures.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/TargetTypeParameter.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newLambda/OverloadResolutionSAM.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/DetectPolyExpressionInReturnsOfExplicitlyTypedLambdaWhenPrimitiveCouldWin.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/IDEA102800.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/PertinentToApplicabilityOfExplicitlyTypedLambda.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/VoidValueCompatibilityOfImplicitlyTypedLambda.java
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/params/MethodApplicability.java

index 6cba2e140fc8aa329028fbebf6d0efb253e6531e..621dc78e208e22a5aca81cfec42e5665c3042ea5 100644 (file)
@@ -569,12 +569,13 @@ public class HighlightMethodUtil {
 
   @Nullable
   static HighlightInfo checkAmbiguousMethodCallArguments(@NotNull PsiReferenceExpression referenceToMethod,
-                                                @NotNull JavaResolveResult[] resolveResults,
-                                                @NotNull PsiExpressionList list,
-                                                final PsiElement element,
-                                                @NotNull JavaResolveResult resolveResult,
-                                                @NotNull PsiMethodCallExpression methodCall,
-                                                @NotNull PsiResolveHelper resolveHelper) {
+                                                         @NotNull JavaResolveResult[] resolveResults,
+                                                         @NotNull PsiExpressionList list,
+                                                         final PsiElement element,
+                                                         @NotNull JavaResolveResult resolveResult,
+                                                         @NotNull PsiMethodCallExpression methodCall,
+                                                         @NotNull PsiResolveHelper resolveHelper, 
+                                                         @NotNull PsiElement elementToHighlight) {
     MethodCandidateInfo methodCandidate1 = null;
     MethodCandidateInfo methodCandidate2 = null;
     for (JavaResolveResult result : resolveResults) {
@@ -594,7 +595,6 @@ public class HighlightMethodUtil {
 
     String description;
     String toolTip;
-    PsiElement elementToHighlight;
     HighlightInfoType highlightInfoType = HighlightInfoType.ERROR;
     if (methodCandidate2 != null) {
       PsiMethod element1 = methodCandidate1.getElement();
@@ -617,7 +617,6 @@ public class HighlightMethodUtil {
       }
       description = JavaErrorMessages.message("ambiguous.method.call", m1, m2);
       toolTip = createAmbiguousMethodHtmlTooltip(new MethodCandidateInfo[]{methodCandidate1, methodCandidate2});
-      elementToHighlight = list;
     }
     else {
       if (element != null && !resolveResult.isAccessible()) {
@@ -632,9 +631,6 @@ public class HighlightMethodUtil {
         if (candidates.length == 0) {
           return null;
         }
-        else {
-          elementToHighlight = list;
-        }
       }
       toolTip = XmlStringUtil.escapeString(description);
     }
index 1357b90ec0cb0ab16f0a3bf9594ac4e823b9bc4d..226e1593818460a56265efe33371d718dffef4f9 100644 (file)
@@ -553,7 +553,9 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
             // this check is for fake expression from JspMethodCallImpl
             referenceExpression.getParent() == expression) {
           try {
-            myHolder.add(HighlightMethodUtil.checkAmbiguousMethodCallArguments(referenceExpression, results, list, resolved, result, expression, myResolveHelper));
+            if (PsiTreeUtil.findChildrenOfType(expression.getArgumentList(), PsiLambdaExpression.class).isEmpty()) {
+              myHolder.add(HighlightMethodUtil.checkAmbiguousMethodCallArguments(referenceExpression, results, list, resolved, result, expression, myResolveHelper, list));
+            }
           }
           catch (IndexNotReadyException ignored) {
           }
@@ -1210,8 +1212,12 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
       PsiExpressionList list = methodCallExpression.getArgumentList();
       if (!HighlightMethodUtil.isDummyConstructorCall(methodCallExpression, myResolveHelper, list, expression)) {
         try {
-          myHolder.add(HighlightMethodUtil.checkAmbiguousMethodCallIdentifier(expression, results, list, resolved, result,
-                                                                              methodCallExpression, myResolveHelper));
+          myHolder.add(HighlightMethodUtil.checkAmbiguousMethodCallIdentifier(expression, results, list, resolved, result, methodCallExpression, myResolveHelper));
+          
+          if (!PsiTreeUtil.findChildrenOfType(methodCallExpression.getArgumentList(), PsiLambdaExpression.class).isEmpty()) {
+            myHolder.add(HighlightMethodUtil
+              .checkAmbiguousMethodCallArguments(expression, results, list, resolved, result, methodCallExpression, myResolveHelper, expression.getReferenceNameElement()));
+          }
         }
         catch (IndexNotReadyException ignored) {
         }
index 6c664dd9e65a677da0d5e299fb48a00f1fa1686c..2e95d0205abb0d09cd58c85a92efb72d2b4bd522 100644 (file)
@@ -22,6 +22,6 @@ class AmbiguityRawGenerics {
     <Z> void foo(I3<Z> s) { }
 
     void bar() {
-        foo<error descr="Ambiguous method call: both 'AmbiguityRawGenerics.foo(I1)' and 'AmbiguityRawGenerics.foo(I2)' match">(()-> { throw new RuntimeException(); })</error>;
+        <error descr="Ambiguous method call: both 'AmbiguityRawGenerics.foo(I1)' and 'AmbiguityRawGenerics.foo(I2)' match">foo</error>(()-> { throw new RuntimeException(); });
     }
 }
\ No newline at end of file
index 1512dd0abc4310760ffc6e5381f135b390aac5df..b8fb475c6c0b599a34a58512a50daf470afe2a5b 100644 (file)
@@ -1,6 +1,6 @@
 public interface IDEA99969 {
   default IntStream distinct(Stream s) {
-    return s.map(i -> <error descr="Inconvertible types; cannot cast '<lambda parameter>' to 'int'">(int) i</error>);
+    return s.<error descr="Ambiguous method call: both 'Stream.map(Function)' and 'Stream.map(IntFunction)' match">map</error>(i -> <error descr="Inconvertible types; cannot cast '<lambda parameter>' to 'int'">(int) i</error>);
   }
 }
 interface Stream<T> {
index a6abf3db299aa90bef743c521def2daede16e36d..99a0468e772a01560e098a069e185967c1c59168 100644 (file)
@@ -20,7 +20,7 @@ class Test {
         void m(IL lm, II s) { }
 
         {
-            m<error descr="Ambiguous method call: both 'Test.m(II, IL)' and 'Test.m(IL, II)' match">(() -> 1,  () ->1)</error>;
+            <error descr="Ambiguous method call: both 'Test.m(II, IL)' and 'Test.m(IL, II)' match">m</error>(() -> 1,  () ->1);
         }
 
 
@@ -42,17 +42,17 @@ class Test {
          {
             mi (1);
             m2();
-            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(()->1)</error>;
+            <error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">m2</error>(()->1);
             m2(()->1, ()->1);
             m2(()->1, ()->1, ()->1);
 
             m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(null, null, null)</error>;
-            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(()->1, null, null)</error>;
-            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(null, ()->1, null)</error>;
-            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(null, null, ()->1)</error>;
-            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(()->1, ()->1, null)</error>;
-            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(null, ()->1, ()->1)</error>;
-            m2<error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">(()->1, null, ()->1)</error>;
+            <error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">m2</error>(()->1, null, null);
+            <error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">m2</error>(null, ()->1, null);
+            <error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">m2</error>(null, null, ()->1);
+            <error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">m2</error>(()->1, ()->1, null);
+            <error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">m2</error>(null, ()->1, ()->1);
+            <error descr="Ambiguous method call: both 'Test.m2(II, II...)' and 'Test.m2(IL...)' match">m2</error>(()->1, null, ()->1);
 
             m2(()->1L, null, null);
             m2(null, ()->1L, null);
@@ -73,8 +73,8 @@ class Test {
             m3(() -> 1, () -> 1, () -> 1);
 
             m3<error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">(null, null)</error>;
-            m3<error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">(() -> 1,  null)</error>;
-            m3<error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">(null, () -> 1)</error>;
+            <error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">m3</error>(() -> 1,  null);
+            <error descr="Ambiguous method call: both 'Test.m3(II...)' and 'Test.m3(IL...)' match">m3</error>(null, () -> 1);
             m3(() -> 1L, null);
             m3(null, () -> 1L);
         }
index 83db64423f6f00653bb04ecb29069377d7276577..fba4d622f4577da4ebe4ecde72ee83ebaa470a11 100644 (file)
@@ -19,8 +19,8 @@ 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="Cannot resolve method 'foo(<lambda expression>)'">(p -> 1.0)</error>;
+        inn.<error descr="Ambiguous method call: both 'Inner.m8(IO<? extends Number>)' and 'Inner.m8(IN<? extends Double>)' match">m8</error>(p -> 1.0);
+        new Test<Number, Integer>().<error descr="Cannot resolve method 'foo(<lambda expression>)'">foo</error>(p -> 1.0);
 
     }
 }
index ca4938fb569b96fefc54ceaa4fdc1c04bdbcd27c..da88474bfbe0f86ac70856800d3594d1d7ea1510 100644 (file)
@@ -8,8 +8,8 @@ class Test {
         IntStream mi = sp.map(Inner::foo);
         Stream<Integer> mI = sp.map(Inner::fooBoxed);
 
-        IntStream li = sp.map(inner->inner.<error descr="Cannot resolve method 'foo()'">foo</error>());
-        Stream<Integer> lI = sp.map(inner -> inner.<error descr="Cannot resolve method 'fooBoxed()'">fooBoxed</error>());
+        IntStream li = sp.<error descr="Ambiguous method call: both 'Stream.map(Function<? super Inner, ? extends R>)' and 'Stream.map(IntFunction<? super Inner>)' match">map</error>(inner->inner.<error descr="Cannot resolve method 'foo()'">foo</error>());
+        Stream<Integer> lI = sp.<error descr="Ambiguous method call: both 'Stream.map(Function<? super Inner, ? extends Integer>)' and 'Stream.map(IntFunction<? super Inner>)' match">map</error>(inner -> inner.<error descr="Cannot resolve method 'fooBoxed()'">fooBoxed</error>());
     }
 
     interface Stream<T> {
index 5b9d5d74e31ec063e6ec1d1495642221b05e52bd..291f7e2b0c91ee8748a3b8e9b7fd1e3c0ff4c917 100644 (file)
@@ -1,8 +1,8 @@
 class IntStream {
   private void foo(IntStream s) {
-    s.map<error descr="Ambiguous method call: both 'IntStream.map(IntUnaryOperator)' and 'IntStream.map(ObjIntFunction<Integer>)' match">(i -> 1 << i)</error>;
-    s.map<error descr="Ambiguous method call: both 'IntStream.map(IntUnaryOperator)' and 'IntStream.map(ObjIntFunction<Integer>)' match">(i -> 1)</error>;
-    s.map<error descr="Ambiguous method call: both 'IntStream.map(IntUnaryOperator)' and 'IntStream.map(ObjIntFunction<Integer>)' match">(i -> i)</error>;
+    s.<error descr="Ambiguous method call: both 'IntStream.map(IntUnaryOperator)' and 'IntStream.map(ObjIntFunction<Integer>)' match">map</error>(i -> 1 << i);
+    s.<error descr="Ambiguous method call: both 'IntStream.map(IntUnaryOperator)' and 'IntStream.map(ObjIntFunction<Integer>)' match">map</error>(i -> 1);
+    s.<error descr="Ambiguous method call: both 'IntStream.map(IntUnaryOperator)' and 'IntStream.map(ObjIntFunction<Integer>)' match">map</error>(i -> i);
   }
 
   public static void main(String[] args) {
index 412cbe527c7a466f8fb82085f486480f552c2c50..2714dfdf613f98c4e175cd14c8f08479307259e6 100644 (file)
@@ -22,7 +22,7 @@ class AmbiguityVarargs {
 
     void test() {
         foo(()->{});
-        foo<error descr="Ambiguous method call: both 'AmbiguityVarargs.foo(I1<String>)' and 'AmbiguityVarargs.foo(IV<String>)' match">((a1) -> {})</error>;
+        <error descr="Ambiguous method call: both 'AmbiguityVarargs.foo(I1<String>)' and 'AmbiguityVarargs.foo(IV<String>)' match">foo</error>((a1) -> {});
         foo((a1, a2)->{});
     }
 }
\ No newline at end of file
index b5a3b3579f16b378d03d58ac5aff813d2b2a7f53..9134ede93aabd0583ed76c89fe02688f1623e25f 100644 (file)
@@ -25,7 +25,7 @@ class ReturnTypeIncompatibility {
     }
 
     public static void main(String[] args) {
-        call<error descr="Cannot resolve method 'call(<lambda expression>)'">(i-> {return i;})</error>;
+        <error descr="Cannot resolve method 'call(<lambda expression>)'">call</error>(i-> {return i;});
     }
 }
 
@@ -57,7 +57,7 @@ class ReturnTypeCompatibility {
     }
 
     public static void main(String[] args) {
-        call<error descr="Cannot resolve method 'call(<lambda expression>)'">(i-> {return i;})</error>;
+        <error descr="Cannot resolve method 'call(<lambda expression>)'">call</error>(i-> {return i;});
     }
 }
 
index 7b1d532382f38efa002d32d7f43fdf830a200407..d5dcb3d9472d6b55b6d5ed29a6d1c92316943417 100644 (file)
@@ -21,9 +21,9 @@ class Test {
     }
 
     void foo(Foo<String> as, final Foo<Character> ac) {
-        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>);
+        boolean b1 = as.<error descr="Ambiguous method call: both 'Foo.forAll(I<String, Boolean>)' and 'Foo.forAll(II<String, String>)' match">forAll</error>(s -> ac.<error descr="Cannot resolve method 'forAll(<lambda expression>)'">forAll</error>(c -> false));
+        String s1 = as.<error descr="Ambiguous method call: both 'Foo.forAll(I<String, Boolean>)' and 'Foo.forAll(II<String, String>)' match">forAll</error>(s -> ac.<error descr="Cannot resolve method 'forAll(<lambda expression>)'">forAll</error>(c -> ""));
+        boolean b2 = as.<error descr="Ambiguous method call: both 'Foo.forAll(I<String, Boolean>)' and 'Foo.forAll(II<String, String>)' match">forAll</error>(s -> ac.<error descr="Cannot resolve method 'forAll(<lambda expression>)'">forAll</error>(c -> ""));
         String s2 = as.forAll2(s -> ac.forAll2(c -> <error descr="Bad return type in lambda expression: boolean cannot be converted to String">false</error>));
         boolean b3 = as.forAll((I<String, Boolean>)s -> ac.forAll((I<Character, Boolean>)c -> <error descr="Bad return type in lambda expression: String cannot be converted to Boolean">""</error>));
         String s3 = as.forAll((II<String, String>)s -> ac.forAll((II<Character, String>)c -> <error descr="Bad return type in lambda expression: boolean cannot be converted to String">false</error>));
index 951858bae63897cd494fa6f6bd2ca75045642401..580b76317092d88bea8e6ace96aa79d052ddbdc2 100644 (file)
@@ -23,7 +23,7 @@ class Test {
 
   void test() {
     call(() -> { });
-    call<error descr="Ambiguous method call: both 'Test.call(I1)' and 'Test.call(IVarargs)' match">(p1 -> { })</error>;
+    <error descr="Ambiguous method call: both 'Test.call(I1)' and 'Test.call(IVarargs)' match">call</error>(p1 -> { });
     call((p1, p2) -> {});
   }
 }
index 8d71a82cc6b4a0448379ce0da6441023406c87d2..12fa88aafada15a9cd80c4968f21b1533d7c60fd 100644 (file)
@@ -7,6 +7,6 @@ class Test {
   public static void call(I i) {  }
 
   public static void main(String[] args)   {
-      call<error descr="Ambiguous method call: both 'Test.call(IStr)' and 'Test.call(I)' match">(()-> null)</error>;
+      <error descr="Ambiguous method call: both 'Test.call(IStr)' and 'Test.call(I)' match">call</error>(()-> null);
   }
 }
\ No newline at end of file
index e5469aba7a09cb757a6be6b53164c6ceabff9b67..8299f3984481911415f41eb202be16d80cdc60a6 100644 (file)
@@ -12,7 +12,7 @@ class MS {
 
   void test(boolean cond) {
     m(cond ? () -> 26 : () -> 24);
-    m<error descr="Cannot resolve method 'm(?)'">(cond ? () -> 26 : () -> new Integer(42))</error>;
+    <error descr="Cannot resolve method 'm(?)'">m</error>(cond ? () -> 26 : () -> new Integer(42));
     m(cond ? () -> new Integer(26) : () -> new Integer(42));
   }
 }
index e2ac37c8d2e3ad4875ae4cf3b51aab114e22f559..d96e9cceee3a1ece58226da05a4d3031cbee9f0e 100644 (file)
@@ -22,7 +22,7 @@ class Test {
   }
 
   public void test() {
-    foo<error descr="Ambiguous method call: both 'Test.foo(RunnableX)' and 'Test.foo(Callable<List<?>>)' match">(()->  new ArrayList<Void>() )</error>;
+    <error descr="Ambiguous method call: both 'Test.foo(RunnableX)' and 'Test.foo(Callable<List<?>>)' match">foo</error>(()->  new ArrayList<Void>() );
   }
 
 }
index 550ecf8f49f6769055ac0e42709b97a55c82d6cd..1164a45f976ce41713c36ffe9da1a3458532eaae 100644 (file)
@@ -3,7 +3,7 @@ import java.util.function.Supplier;
 class Test {
 
   public static void main(String... args) {
-    c<error descr="Cannot resolve method 'c(<lambda expression>, <lambda expression>)'">(() -> 3, () -> 10)</error>;
+    <error descr="Cannot resolve method 'c(<lambda expression>, <lambda expression>)'">c</error>(() -> 3, () -> 10);
   }
 
   public static <T> void c(Supplier<T> s1, Supplier<T> s2) {}
index a76b40505e07b34e7a2e0b8f12db13ca887a5aa9..364a27793145a2d5d1b969ff07efb4c95150df20 100644 (file)
@@ -14,7 +14,7 @@ class Test {
   void m1(ILong l, Object i) {}
 
   void test() {
-    m<error descr="Ambiguous method call: both 'Test.m(IInt, Long)' and 'Test.m(ILong, Integer)' match">(() -> 1, null)</error>;
+    <error descr="Ambiguous method call: both 'Test.m(IInt, Long)' and 'Test.m(ILong, Integer)' match">m</error>(() -> 1, null);
     m1(() -> 1, null);
   }
 }
\ No newline at end of file
index 323b8505dbd1b4aadd1459b0ac5559b09702cb02..e2adfb39896a051811c3ac97d2d9419b0808146a 100644 (file)
@@ -11,12 +11,12 @@ class Test {
   }
 
   void test(boolean cond) {
-    m<error descr="Cannot resolve method 'm(<lambda expression>)'">(() -> {
+    <error descr="Cannot resolve method 'm(<lambda expression>)'">m</error>(() -> {
       if (cond)
         return 42;
       else
         return foo();
-    })</error>;
+    });
 
     m(() -> {
       return foo();
index 299c620daeb24fec4a6695a93e8d7016f34dd307..23dc3b0237d2dbc19bc4084b5f481f19865b3080 100644 (file)
@@ -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 : -i).boxed();
+    Supplier<Stream<Integer>> si = () -> instr.<error descr="Ambiguous method call: both 'IntStream1.map(IntFunction<Integer>)' and 'IntStream1.map(IntUnaryOperator)' match">map</error> ((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);
index adaea236cd6210e9ec5b9bebd2d5361608cb9d73..869fdf0b572016ee37b765ea2719a0bcd6f204e2 100644 (file)
@@ -12,6 +12,6 @@ abstract class PertinentToApplicabilityOfExplicitlyTypedLambdaTest {
   abstract void foo(B b);
 
   {
-    foo<error descr="Cannot resolve method 'foo(<lambda expression>)'">(x -> y -> 42)</error>;
+    <error descr="Cannot resolve method 'foo(<lambda expression>)'">foo</error>(x -> y -> 42);
   }
 }
index 443f6339121d85503acf39438d0f97d06091e857..eab32249a3bf6b0d9526733657fd27cec9a40f04 100644 (file)
@@ -14,10 +14,10 @@ abstract class Test {
     foo(x -> {
       return x += 1;
     });
-    foo<error descr="Ambiguous method call: both 'Test.foo(A)' and 'Test.foo(B)' match">(x -> x += 1)</error>;
+    <error descr="Ambiguous method call: both 'Test.foo(A)' and 'Test.foo(B)' match">foo</error>(x -> x += 1);
     foo(x -> 1);
     foo(x -> <error descr="Operator '!' cannot be applied to 'int'">!x</error>);
-    foo<error descr="Ambiguous method call: both 'Test.foo(A)' and 'Test.foo(B)' match">(x -> ++x)</error>;
+    <error descr="Ambiguous method call: both 'Test.foo(A)' and 'Test.foo(B)' match">foo</error>(x -> ++x);
     foo(x -> o instanceof String ? 1 : 0);
   }
 }
index aa18671e3f487745064de4efa362b0c112378158..6b6945ab6a01598bf90ba8c233f8bbd9217a161c 100644 (file)
@@ -14,7 +14,7 @@ class Foo {
   void foo(K k){}
 
   void bar() {
-    foo((p) -> {
+    <error descr="Ambiguous method call: both 'Foo.foo(I)' and 'Foo.foo(K)' match">foo</error>((p) -> {
       System.out.println<error descr="Cannot resolve method 'println(<lambda parameter>)'">(p)</error>;
     });
 
@@ -26,9 +26,9 @@ class Foo {
       System.out.println(s);
     });
 
-    foo<error descr="Cannot resolve method 'foo(<lambda expression>)'">((String p, String k) -> {
+    <error descr="Cannot resolve method 'foo(<lambda expression>)'">foo</error>((String p, String k) -> {
       System.out.println(p);
-    })</error>;
+    });
   }
 }
 
@@ -62,7 +62,7 @@ class WithTypeParams {
         System.out.println(p);
       });
   
-      foo<error descr="Cannot resolve method 'foo(<lambda expression>)'">((int k) -> {System.out.println(k);})</error>;
+      <error descr="Cannot resolve method 'foo(<lambda expression>)'">foo</error>((int k) -> {System.out.println(k);});
     }
   }
 }
\ No newline at end of file