diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java
index a46f56b30bf..a146fa1b2e9 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java
@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
@@ -133,7 +134,7 @@ public class ImportsResolver {
 
         if (lookupMode == LookupMode.EVERYTHING) {
             for (JetImportDirective importDirective : importDirectives) {
-                reportUselessImport(importDirective, fileScope, resolvedDirectives, trace);
+                reportUselessImport(importDirective, fileScope, resolvedDirectives.get(importDirective), trace);
             }
         }
     }
@@ -167,15 +168,15 @@ public class ImportsResolver {
         }
     }
 
-    private static void reportUselessImport(
+    public static void reportUselessImport(
         @NotNull JetImportDirective importDirective,
-        @NotNull WritableScope fileScope,
-        @NotNull Map<JetImportDirective, Collection<? extends DeclarationDescriptor>> resolvedDirectives,
+        @NotNull JetScope fileScope,
+        @Nullable Collection<? extends DeclarationDescriptor> resolvedDirectives,
         @NotNull BindingTrace trace
     ) {
 
         JetExpression importedReference = importDirective.getImportedReference();
-        if (importedReference == null || !resolvedDirectives.containsKey(importDirective)) {
+        if (importedReference == null || resolvedDirectives == null) {
             return;
         }
         Name aliasName = JetPsiUtil.getAliasName(importDirective);
@@ -184,7 +185,7 @@ public class ImportsResolver {
         }
 
         boolean uselessHiddenImport = true;
-        for (DeclarationDescriptor wasResolved : resolvedDirectives.get(importDirective)) {
+        for (DeclarationDescriptor wasResolved : resolvedDirectives) {
             DeclarationDescriptor isResolved = null;
             if (wasResolved instanceof ClassDescriptor) {
                 isResolved = fileScope.getClassifier(aliasName);
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java
index 142446b4b50..51a0d317c26 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java
@@ -54,10 +54,12 @@ public class LazyImportScope implements JetScope, LazyEntity {
     private static class ImportResolveStatus {
         private final LookupMode lookupMode;
         private final JetScope scope;
+        private final Collection<? extends DeclarationDescriptor> descriptors;
 
-        ImportResolveStatus(LookupMode lookupMode, JetScope scope) {
+        ImportResolveStatus(LookupMode lookupMode, JetScope scope, Collection<? extends DeclarationDescriptor> descriptors) {
             this.lookupMode = lookupMode;
             this.scope = scope;
+            this.descriptors = descriptors;
         }
     }
 
@@ -93,16 +95,16 @@ public class LazyImportScope implements JetScope, LazyEntity {
                     Importer.StandardImporter importer = new Importer.StandardImporter(directiveImportScope);
                     directiveUnderResolve = directive;
 
+                    Collection<? extends DeclarationDescriptor> descriptors;
                     try {
-                        Collection<? extends DeclarationDescriptor> descriptors =
-                                resolveSession.getQualifiedExpressionResolver().processImportReference(
-                                        directive,
-                                        rootScope,
-                                        packageDescriptor.getMemberScope(),
-                                        importer,
-                                        traceForImportResolve,
-                                        resolveSession.getModuleDescriptor(),
-                                        mode);
+                        descriptors = resolveSession.getQualifiedExpressionResolver().processImportReference(
+                                directive,
+                                rootScope,
+                                packageDescriptor.getMemberScope(),
+                                importer,
+                                traceForImportResolve,
+                                resolveSession.getModuleDescriptor(),
+                                mode);
                         if (mode == LookupMode.EVERYTHING) {
                             ImportsResolver.checkPlatformTypesMappedToKotlin(
                                     packageDescriptor.getModule(),
@@ -117,7 +119,7 @@ public class LazyImportScope implements JetScope, LazyEntity {
                         directiveImportScope.changeLockLevel(WritableScope.LockLevel.READING);
                     }
 
-                    importResolveStatus = new ImportResolveStatus(mode, directiveImportScope);
+                    importResolveStatus = new ImportResolveStatus(mode, directiveImportScope, descriptors);
                     return directiveImportScope;
                 }
             });
@@ -172,6 +174,11 @@ public class LazyImportScope implements JetScope, LazyEntity {
     public void forceResolveAllContents() {
         for (JetImportDirective importDirective : importsProvider.getAllImports()) {
             getImportScope(importDirective, LookupMode.EVERYTHING);
+
+            ImportResolveStatus status = importedScopesProvider.invoke(importDirective).importResolveStatus;
+            if (status != null && !status.descriptors.isEmpty()) {
+                ImportsResolver.reportUselessImport(importDirective, this, status.descriptors, traceForImportResolve);
+            }
         }
     }