From 250956f8b0d90f648d76597707b186767f19828c Mon Sep 17 00:00:00 2001
From: "Anna.Kozlova" <anna.kozlova@jetbrains.com>
Date: Fri, 13 Oct 2017 10:44:48 +0200
Subject: [PATCH] report inference error if resolution failed (IDEA-179978)

in the issue, non-vararg overload candidate was chosen cause it was not filtered as inapplicable
---
 .../graphInference/InferenceSession.java      |  8 ++-
 .../genericsHighlighting8/IDEA57494.java      |  2 +-
 .../VarargsMethodPreferred.java               | 51 +++++++++++++++++++
 .../GraphInferenceHighlightingTest.java       |  1 +
 4 files changed, 60 insertions(+), 2 deletions(-)
 create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/VarargsMethodPreferred.java

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java
index 5fe5f04dbce5..b968cd03bfda 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/InferenceSession.java
@@ -59,7 +59,7 @@ public class InferenceSession {
       }
       if (second instanceof PsiCapturedWildcardType && !first.isAssignableFrom(second)) {
         final PsiClass conjunct = PsiUtil.resolveClassInType(first);
-        if (conjunct != null && !conjunct.isInterface() ) {
+        if (conjunct != null && !conjunct.isInterface() && !(conjunct instanceof PsiTypeParameter) ) {
           return false;
         }
       }
@@ -1303,6 +1303,12 @@ public class InferenceSession {
         }
       }
     }
+    if (type == PsiType.NULL) {
+      registerIncompatibleErrorMessage("Incompatible upper bounds: " + StringUtil.join(var.getBounds(InferenceBound.UPPER), bound -> {
+        final PsiType substituted = substituteNonProperBound(bound, substitutor);
+        return getPresentableText(substituted != null ? substituted : bound);
+      }, ", "));
+    }
     return type;
   }
 
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA57494.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA57494.java
index c52216cfd7de..ca89388b1a05 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA57494.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA57494.java
@@ -11,6 +11,6 @@ abstract class A1{
     abstract <T> T baz(List<? super T> a);
 
     void bar(List<?> x){
-        <error descr="Incompatible types. Found: 'T', required: 'java.lang.String'">String o = baz(x);</error>
+        String o = <error descr="Incompatible upper bounds: Object, capture of ?, String">baz(x);</error>
     }
 }
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/VarargsMethodPreferred.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/VarargsMethodPreferred.java
new file mode 100644
index 000000000000..f2e702d994d9
--- /dev/null
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/VarargsMethodPreferred.java
@@ -0,0 +1,51 @@
+
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class InferenceTest {
+
+  public static void main(String[] args) {
+    List<SortedMap<String, Double>> results = codeUnderTest();
+
+    assertThat(results, contains(Stream.of(entry("A", 1.0), entry("B", 2.0), entry("C", 3.0))
+                                   .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a, TreeMap::new))));
+
+    System.out.println("ok!");
+  }
+
+  private static List<SortedMap<String, Double>> codeUnderTest() {
+    SortedMap<String, Double> result = new TreeMap<>();
+    result.put("A", 1.0);
+    result.put("B", 2.0);
+    result.put("C", 3.0);
+    return Collections.singletonList(result);
+  }
+
+  private static <K, V> Map.Entry<K, V> entry(K key, V value) {
+    return new AbstractMap.SimpleEntry<>(key, value);
+  }
+
+  public static <T> void assertThat(T actual, Predicate<? super T> matcher) {
+    if (!matcher.test(actual)) throw new AssertionError(String.valueOf(actual));
+  }
+
+  @SafeVarargs
+  public static <E> Predicate<Iterable<? extends E>> contains(E... items) {
+    return Predicate.isEqual(Arrays.asList(items));
+  }
+
+}
+
+class InferenceSimplifiedTest {
+
+  public static void main(final Stream<Entry<String, Double>> entry) {
+    contains(entry.collect(Collectors.toMap(Entry::getKey, null, null, HashMap::new)));
+  }
+
+  @SafeVarargs
+  public static <E> void contains(E... items) { }
+
+}
\ No newline at end of file
diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/lambda/GraphInferenceHighlightingTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/lambda/GraphInferenceHighlightingTest.java
index fd044c5a5e0e..76675f522670 100644
--- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/lambda/GraphInferenceHighlightingTest.java
+++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/lambda/GraphInferenceHighlightingTest.java
@@ -181,6 +181,7 @@ public class GraphInferenceHighlightingTest extends LightDaemonAnalyzerTestCase
 
   public void testPertinentToApplicabilityCheckForBlockLambda() { doTest(); }
   public void testRestoreCapturedWildcardsInReturnTypesWhenNoAdditionalConstraintsDetected() { doTest(); }
+  public void testVarargsMethodPreferred() { doTest(); }
 
   public void testApplicabilityCheckFailsExpressionTypeCheckPasses() {
     doTest();