static imports: don't compare with expected type when it depends on unresolved...

static imports: don't compare with expected type when it depends on unresolved reference (IDEA-163072)

(cherry picked from commit 51d4e993)

java/java-impl/src/com/intellij/codeInsight/ExpectedTypesProvider.java

@@ -987,7 +987,7 @@ public class ExpectedTypesProvider {
           final MethodCandidateInfo info = (MethodCandidateInfo)candidateInfo;
           substitutor = MethodCandidateInfo.ourOverloadGuard.doPreventingRecursion(argumentList, false,
                                                                                    () -> info.inferSubstitutorFromArgs(policy, args));
-          if (!info.isStaticsScopeCorrect() && !method.hasModifierProperty(PsiModifier.STATIC)) continue;
+          if (!info.isStaticsScopeCorrect() && !method.hasModifierProperty(PsiModifier.STATIC) || info.getInferenceErrorMessage() != null) continue;
         }
         else {
           substitutor = MethodCandidateInfo.ourOverloadGuard.doPreventingRecursion(argumentList, false, candidateInfo::getSubstitutor);

java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java

@@ -184,8 +184,12 @@ public class ExpressionCompatibilityConstraint extends InputOutputConstraintForm
             session.registerIncompatibleErrorMessage(message);
           }
         }
+        return null;
+      }
+      else {
+        session.registerIncompatibleErrorMessage("Failed to resolve argument");
+        return null;
       }
-      return null;
     }
     return session;
   }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/ChainedInference.java

@@ -3,8 +3,8 @@ import java.util.*;
 class Main {
 
     void foo(List<Integer> list) {
-        bar(list, i -> i.intValue(), i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>());
-        bar1(list, i -> i.intValue(), i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>());
+        bar(list, <error descr="Failed to resolve argument">i -> i.intValue()</error>, i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>());
+        bar1(list, <error descr="Failed to resolve argument">i -> i.intValue()</error>, i -> i.<error descr="Cannot resolve method 'unknown()'">unknown</error>());
     }
 
     <U, S_IN, S_OUT, R> R bar(List<S_IN> list,

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/UncheckedConversionDuringProperTypeExpressionConstraintResolution.java

@@ -48,7 +48,7 @@ class Test2 {
   {
     Class c = D.class;
 
-    D<String> d = new D<>(s -> s.<error descr="Cannot resolve method 'isEmpty()'">isEmpty</error>(), c);
+    D<String> d = new D<error descr="Cannot infer arguments"><></error>(s -> s.<error descr="Cannot resolve method 'isEmpty()'">isEmpty</error>(), c);
     D<String> d1 = D.create(s -> s.<error descr="Cannot resolve method 'isEmpty()'">isEmpty</error>(), c);
   }
 }
\ No newline at end of file

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/staticImportMethod8/afterOneCorrectUsage.java

+// "Import static method 'java.util.stream.Collectors.toList'" "true"
+
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+
+public class X {
+
+  {
+    System.out.println(Stream.of(123, 456)
+                         .map(i -> i + 1)
+                         .collect(toList()));
+  }
+}
+
+class Y {
+  private static void toList() {}
+}
\ No newline at end of file

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/staticImportMethod8/beforeOneCorrectUsage.java

+// "Import static method 'java.util.stream.Collectors.toList'" "true"
+
+import java.util.stream.Stream;
+
+public class X {
+
+  {
+    System.out.println(Stream.of(123, 456)
+                         .map(i -> i + 1)
+                         .collect(toLi<caret>st()));
+  }
+}
+
+class Y {
+  private static void toList() {}
+}
\ No newline at end of file