Import directives are resolved in lazy mode

compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java

@@ -125,11 +125,8 @@ public class ImportsResolver {
                 resolvedDirectives.put(importDirective, descriptors);
             }
 
-            JetExpression importedReference = importDirective.getImportedReference();
+            if (lookupMode != LookupMode.ONLY_CLASSES) {
-            if (lookupMode != LookupMode.ONLY_CLASSES && importedReference != null) {
+                checkPlatformTypesMappedToKotlin(module, trace, importDirective, descriptors);
-                for (DeclarationDescriptor descriptor : descriptors) {
-                    reportPlatformClassMappedToKotlin(module, trace, importedReference, descriptor);
-                }
             }
         }
         delayedImporter.processImports();
@@ -141,6 +138,20 @@ public class ImportsResolver {
         }
     }
 
+    public static void checkPlatformTypesMappedToKotlin(
+            @NotNull ModuleDescriptor module,
+            @NotNull BindingTrace trace,
+            @NotNull JetImportDirective importDirective,
+            @NotNull Collection<? extends DeclarationDescriptor> descriptors
+    ) {
+        JetExpression importedReference = importDirective.getImportedReference();
+        if (importedReference != null) {
+            for (DeclarationDescriptor descriptor : descriptors) {
+                reportPlatformClassMappedToKotlin(module, trace, importedReference, descriptor);
+            }
+        }
+    }
+
     public static void reportPlatformClassMappedToKotlin(
             @NotNull ModuleDescriptor module,
             @NotNull BindingTrace trace,

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java

@@ -32,6 +32,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil;
+import org.jetbrains.jet.lang.resolve.lazy.LazyImportScope;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -174,8 +175,14 @@ public class TopDownAnalyzer {
                                     DescriptorResolver.resolvePackageHeader(packageDirective, moduleDescriptor, trace);
                                     registerDeclarations(file.getDeclarations());
                                 }
+                                resolveAndCheckImports(file, resolveSession);
                             }
 
+                            private void resolveAndCheckImports(@NotNull JetFile file, @NotNull ResolveSession resolveSession) {
+                               LazyImportScope fileScope = resolveSession.getScopeProvider().getExplicitImportsScopeForFile(file);
+                               fileScope.forceResolveAllContents();
+                           }
+
                             private void visitClassOrObject(@NotNull JetClassOrObject classOrObject) {
                                 c.getClasses().put(
                                         classOrObject,

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java

@@ -94,14 +94,23 @@ public class LazyImportScope implements JetScope, LazyEntity {
                     directiveUnderResolve = directive;
 
                     try {
-                        resolveSession.getQualifiedExpressionResolver().processImportReference(
+                        Collection<? extends DeclarationDescriptor> descriptors =
-                                directive,
+                                resolveSession.getQualifiedExpressionResolver().processImportReference(
-                                rootScope,
+                                        directive,
-                                packageDescriptor.getMemberScope(),
+                                        rootScope,
-                                importer,
+                                        packageDescriptor.getMemberScope(),
-                                traceForImportResolve,
+                                        importer,
-                                resolveSession.getModuleDescriptor(),
+                                        traceForImportResolve,
-                                mode);
+                                        resolveSession.getModuleDescriptor(),
+                                        mode);
+                        if (mode == LookupMode.EVERYTHING) {
+                            ImportsResolver.checkPlatformTypesMappedToKotlin(
+                                    packageDescriptor.getModule(),
+                                    traceForImportResolve,
+                                    directive,
+                                    descriptors
+                            );
+                        }
                     }
                     finally {
                         directiveUnderResolve = null;
@@ -323,4 +332,4 @@ public class LazyImportScope implements JetScope, LazyEntity {
         p.popIndent();
         p.println("}");
     }
-}
+}