unused imports: don't warn if resolve produces no results but multi resolve does (IDEA-206347)

java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RefCountHolder.java

@@ -164,6 +164,15 @@ class RefCountHolder {
     if (resolveScope instanceof PsiImportStatementBase) {
       registerImportStatement(ref, (PsiImportStatementBase)resolveScope);
     }
+    else if (refElement == null && ref instanceof PsiJavaReference) {
+      for (JavaResolveResult result : ((PsiJavaReference)ref).multiResolve(true)) {
+        resolveScope = result.getCurrentFileResolveScope();
+        if (resolveScope instanceof PsiImportStatementBase) {
+          registerImportStatement(ref, (PsiImportStatementBase)resolveScope);
+          break;
+        }
+      }
+    }
   }
 
   private void registerImportStatement(@NotNull PsiReference ref, @NotNull PsiImportStatementBase importStatement) {

java/java-analysis-impl/src/com/intellij/codeInspection/unusedImport/ImportsAreUsedVisitor.java

@@ -71,7 +71,13 @@ class ImportsAreUsedVisitor extends JavaRecursiveElementWalkingVisitor {
     }
     // during typing there can be incomplete code
     final JavaResolveResult resolveResult = reference.advancedResolve(true);
-    final PsiElement element = resolveResult.getElement();
+    PsiElement element = resolveResult.getElement();
+    if (element == null) {
+      JavaResolveResult[] results = reference.multiResolve(false);
+      if (results.length > 0) {
+        element = results[0].getElement();
+      }
+    }
     if (!(element instanceof PsiMember)) {
       return;
     }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/unusedImports/UnresolvedReferencesInsideAmbiguousCallToImportedMethod.java

@@ -0,0 +1,6 @@
+import static a.A.foo;
+class Test {
+     {
+          foo(<error descr="Cannot resolve method 'unresolvedMethodCall()'">unresolvedMethodCall</error>());
+     }
+}

java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/UnusedImportsTest.java

@@ -92,6 +92,14 @@ public class UnusedImportsTest extends LightCodeInsightFixtureTestCase {
     myFixture.checkHighlighting(true,false, false);
   }
 
+  public void testUnresolvedReferencesInsideAmbiguousCallToImportedMethod() {
+    myFixture.addClass("package a; public class A {\n" +
+                       " public static void foo(Object o) {}\n" +
+                       " public static void foo(String s) {}\n" +
+                       "}");
+    doTest();
+  }
+
   private void doTest() {
     myFixture.configureByFile(getTestName(false) + ".java");
     myFixture.checkHighlighting(true, false, false);

plugins/InspectionGadgets/test/com/siyeh/igtest/imports/globalInspection/UnresolvedReferencesInsideAmbiguousCallToImportedMethod/expected.xml

@@ -0,0 +1 @@
+<problems/>

plugins/InspectionGadgets/testsrc/com/siyeh/ig/imports/UnusedImportGlobalInspectionTest.java

@@ -83,6 +83,21 @@ public class UnusedImportGlobalInspectionTest extends LightCodeInsightFixtureTes
            "}}");
   }
 
+  
+  public void testUnresolvedReferencesInsideAmbiguousCallToImportedMethod() {
+    myFixture.addClass("package a; public class A {\n" +
+                       " public static void foo(Object o) {}\n" +
+                       " public static void foo(String s) {}\n" +
+                       "}");
+    doTest("import static a.A.foo;\n" +
+           "class Test {\n" +
+           "     {\n" +
+           "          foo(<error descr=\"Cannot resolve method 'unresolvedMethodCall()'\">unresolvedMethodCall</error>());\n" +
+           "     }\n" +
+           "}");
+  }
+
+  
   public void testNoHighlightingInInvalidCode() {
     myFixture.configureByText("a.java",
                               "import<EOLError></EOLError>\n" +