IDEA-71244 (NPE at single-type/single-static import conflict fixed)

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

@@ -2019,18 +2019,18 @@ public class HighlightUtil {
 
   @Nullable
   public static HighlightInfo checkSingleImportClassConflict(PsiImportStatement statement,
-                                                             Map<String, Pair<PsiImportStaticReferenceElement, PsiClass>> singleImportedClasses) {
+                                                             Map<String, Pair<PsiImportStaticReferenceElement, PsiClass>> importedClasses) {
     if (statement.isOnDemand()) return null;
     PsiElement element = statement.resolve();
     if (element instanceof PsiClass) {
       String name = ((PsiClass)element).getName();
-      Pair<PsiImportStaticReferenceElement, PsiClass> imported = singleImportedClasses.get(name);
+      Pair<PsiImportStaticReferenceElement, PsiClass> imported = importedClasses.get(name);
       PsiClass importedClass = imported == null ? null : imported.getSecond();
       if (importedClass != null && !element.getManager().areElementsEquivalent(importedClass, element)) {
         String description = JavaErrorMessages.message("single.import.class.conflict", formatClass(importedClass));
         return HighlightInfo.createHighlightInfo(HighlightInfoType.ERROR, statement, description);
       }
-      singleImportedClasses.put(name, Pair.create((PsiImportStaticReferenceElement)statement.getReference(), (PsiClass)element));
+      importedClasses.put(name, Pair.create((PsiImportStaticReferenceElement)null, (PsiClass)element));
     }
     return null;
   }

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

@@ -445,7 +445,9 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
 
   @Override
   public void visitImportStatement(final PsiImportStatement statement) {
-    if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkSingleImportClassConflict(statement, mySingleImportedClasses));
+    if (!myHolder.hasErrorResults()) {
+      myHolder.add(HighlightUtil.checkSingleImportClassConflict(statement, mySingleImportedClasses));
+    }
   }
 
   @Override
@@ -471,9 +473,11 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
           final Pair<PsiImportStaticReferenceElement, PsiClass> imported = mySingleImportedClasses.get(refName);
           final PsiClass aClass = imported == null ? null : imported.getSecond();
           if (aClass != null && !manager.areElementsEquivalent(aClass, element)) {
-            description = imported.getFirst().equals(ref)
-                          ? JavaErrorMessages.message("class.is.ambiguous.in.single.static.import", refName)
-                          : JavaErrorMessages.message("class.is.already.defined.in.single.static.import", refName);
+            description = imported.first == null
+                          ? JavaErrorMessages.message("single.import.class.conflict", refName)
+                          : imported.first.equals(ref)
+                            ? JavaErrorMessages.message("class.is.ambiguous.in.single.static.import", refName)
+                            : JavaErrorMessages.message("class.is.already.defined.in.single.static.import", refName);
           }
           mySingleImportedClasses.put(refName, Pair.create(ref, (PsiClass)element));
         }
@@ -481,7 +485,7 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh
           final Pair<PsiImportStaticReferenceElement, PsiField> imported = mySingleImportedFields.get(refName);
           final PsiField field = imported == null ? null : imported.getSecond();
           if (field != null && !manager.areElementsEquivalent(field, element)) {
-            description = imported.getFirst().equals(ref)
+            description = imported.first.equals(ref)
                           ? JavaErrorMessages.message("field.is.ambiguous.in.single.static.import", refName)
                           : JavaErrorMessages.message("field.is.already.defined.in.single.static.import", refName);
           }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/staticImportConflict/UsageMixed.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2000-2011 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import x.Base1.D;
+import static <error descr="'D' is already defined in a single-type import">x.Base2.D</error>;
+
+class UsageMixed {
+  void use() {
+    <error descr="Reference to 'D' is ambiguous, both 'x.Base1.D' and 'x.Base2.D' match">D</error>.class.getName();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/staticImportConflict/x/Base1.java

@@ -19,6 +19,7 @@ public class Base1 {
   public static final int F = 1;
   public static void m(int i) { }
   public static class F { }
+  public static class D { }
   public interface I1 {
     int IF = 1;
   }

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting7/staticImportConflict/x/Base2.java

@@ -19,6 +19,7 @@ public class Base2 extends Base1 {
   public static final float F = 2.0f;
   public static void m(float f) { }
   public static class F { }
+  public static class D { }
   public interface II extends I1, I2 { }
   public enum E { }
 }

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

@@ -56,4 +56,8 @@ public class AdvHighlightingJdk7Test extends DaemonAnalyzerTestCase {
   public void testStaticImportMethodShadowing() throws Exception {
     doTest(BASE_PATH + "staticImports/P1/MethodShadowing.java", BASE_PATH + "/staticImports", false, false);
   }
+
+  public void testStaticAndSingleImportConflict() throws Exception {
+    doTest(BASE_PATH + "staticImportConflict/UsageMixed.java", BASE_PATH + "/staticImportConflict", false, false);
+  }
 }