diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
index 417296311e3..2fae5178f0b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java
@@ -75,11 +75,11 @@ public class QualifiedExpressionResolver {
     public JetScope processImportReference(
             @NotNull JetImportDirective importDirective,
             @NotNull JetScope scope,
-            @NotNull DeclarationDescriptor shouldBeVisibleFrom,
+            @NotNull ModuleDescriptor moduleDescriptor,
             @NotNull BindingTrace trace,
             @NotNull LookupMode lookupMode
     ) {
-        return importDirectiveProcessor.processImportReference(importDirective, scope, shouldBeVisibleFrom, trace, lookupMode);
+        return importDirectiveProcessor.processImportReference(importDirective, scope, moduleDescriptor, trace, lookupMode);
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
index 471036e54b0..7a1e056992c 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyFileScope.kt
@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
+import org.jetbrains.kotlin.utils.sure
 import java.util.ArrayList
 
 class LazyFileScope private constructor(
@@ -71,31 +72,31 @@ class LazyFileScope private constructor(
                 file.getImportDirectives()
 
             val packageView = getPackageViewDescriptor(file, resolveSession)
-            val rootPackageView = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT)
-                                  ?: throw IllegalStateException("Root package not found")
+            val moduleDescriptor = resolveSession.getModuleDescriptor()
             val packageFragment = resolveSession.getPackageFragment(file.getPackageFqName())
+                    .sure { "Could not find fragment ${file.getPackageFqName()} for file ${file.getName()}" }
 
-            val aliasImportResolver = LazyImportResolver(resolveSession, packageView, AliasImportsIndexed(imports), traceForImportResolve, true)
-            val allUnderImportResolver = LazyImportResolver(resolveSession, packageView, AllUnderImportsIndexed(imports), traceForImportResolve, true)
-            val defaultAliasImportResolver = LazyImportResolver(resolveSession, rootPackageView, AliasImportsIndexed(defaultImports), traceForDefaultImportResolve, false)
-            val defaultAllUnderImportResolver = LazyImportResolver(resolveSession, rootPackageView, AllUnderImportsIndexed(defaultImports), traceForDefaultImportResolve, false)
+            val aliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(imports), traceForImportResolve, true)
+            val allUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(imports), traceForImportResolve, true)
+            val defaultAliasImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AliasImportsIndexed(defaultImports), traceForDefaultImportResolve, false)
+            val defaultAllUnderImportResolver = LazyImportResolver(resolveSession, moduleDescriptor, AllUnderImportsIndexed(defaultImports), traceForDefaultImportResolve, false)
 
             val scopeChain = ArrayList<JetScope>()
 
-            scopeChain.add(LazyImportScope(aliasImportResolver, LazyImportScope.FilteringKind.ALL, "Alias imports in $debugName"))
+            scopeChain.add(LazyImportScope(packageFragment, aliasImportResolver, LazyImportScope.FilteringKind.ALL, "Alias imports in $debugName"))
 
             scopeChain.add(NoSubpackagesInPackageScope(packageView)) //TODO: problems with visibility too
-            scopeChain.add(JetModuleUtil.getSubpackagesOfRootScope(resolveSession.getModuleDescriptor()))
+            scopeChain.add(JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor))
 
-            scopeChain.add(LazyImportScope(defaultAliasImportResolver, LazyImportScope.FilteringKind.ALL, "Default alias imports in $debugName"))
+            scopeChain.add(LazyImportScope(packageFragment, defaultAliasImportResolver, LazyImportScope.FilteringKind.ALL, "Default alias imports in $debugName"))
 
-            scopeChain.add(LazyImportScope(defaultAllUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "Default all under imports in $debugName (visible classes)"))
-            scopeChain.add(LazyImportScope(allUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "All under imports in $debugName (visible classes)"))
+            scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "Default all under imports in $debugName (visible classes)"))
+            scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES, "All under imports in $debugName (visible classes)"))
 
             scopeChain.addAll(additionalScopes)
 
-            scopeChain.add(LazyImportScope(defaultAllUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "Default all under imports in $debugName (invisible classes only)"))
-            scopeChain.add(LazyImportScope(allUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "All under imports in $debugName (invisible classes only)"))
+            scopeChain.add(LazyImportScope(packageFragment, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "Default all under imports in $debugName (invisible classes only)"))
+            scopeChain.add(LazyImportScope(packageFragment, allUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES, "All under imports in $debugName (invisible classes only)"))
 
             return LazyFileScope(scopeChain, aliasImportResolver, allUnderImportResolver, packageFragment, debugName)
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
index 2cd709cb926..e4ad15d1a3b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
@@ -66,7 +66,7 @@ class AliasImportsIndexed(allImports: Collection<JetImportDirective>) : IndexedI
 
 class LazyImportResolver(
         val resolveSession: ResolveSession,
-        val packageView: PackageViewDescriptor,
+        val moduleDescriptor: ModuleDescriptor,
         val indexedImports: IndexedImports,
         private val traceForImportResolve: BindingTrace,
         includeRootPackageClasses: Boolean
@@ -101,11 +101,11 @@ class LazyImportResolver(
                     try {
                         val resolver = resolveSession.getQualifiedExpressionResolver()
                         val directiveImportScope = resolver.processImportReference(
-                                directive, rootScope, packageView, traceForImportResolve, mode)
+                                directive, rootScope, moduleDescriptor, traceForImportResolve, mode)
                         val descriptors = if (directive.isAllUnder()) emptyList() else directiveImportScope.getAllDescriptors()
 
                         if (mode == LookupMode.EVERYTHING) {
-                            PlatformTypesMappedToKotlinChecker.checkPlatformTypesMappedToKotlin(packageView.getModule(), traceForImportResolve, directive, descriptors)
+                            PlatformTypesMappedToKotlinChecker.checkPlatformTypesMappedToKotlin(moduleDescriptor, traceForImportResolve, directive, descriptors)
                         }
 
                         importResolveStatus = ImportResolveStatus(mode, directiveImportScope, descriptors)
@@ -219,6 +219,7 @@ class LazyImportResolver(
 }
 
 class LazyImportScope(
+        private val containingDeclaration: DeclarationDescriptor,
         private val importResolver: LazyImportResolver,
         private val filteringKind: LazyImportScope.FilteringKind,
         private val debugName: String
@@ -235,7 +236,7 @@ class LazyImportScope(
         val visibility = descriptor.getVisibility()
         val includeVisible = filteringKind == FilteringKind.VISIBLE_CLASSES
         if (!visibility.mustCheckInImports()) return includeVisible
-        return Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, descriptor, importResolver.packageView) == includeVisible
+        return Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, descriptor, importResolver.moduleDescriptor) == includeVisible
     }
 
     override fun getClassifier(name: Name): ClassifierDescriptor? {
@@ -285,7 +286,7 @@ class LazyImportScope(
 
     override fun getOwnDeclaredDescriptors() = listOf<DeclarationDescriptor>()
 
-    override fun getContainingDeclaration() = importResolver.packageView
+    override fun getContainingDeclaration() = containingDeclaration
 
     override fun toString() = "LazyImportScope: " + debugName
 
@@ -293,7 +294,7 @@ class LazyImportScope(
         p.println(javaClass.getSimpleName(), ": ", debugName, " {")
         p.pushIndent()
 
-        p.println("packageDescriptor = ", importResolver.packageView)
+        p.println("containingDeclaration = ", containingDeclaration)
 
         importResolver.printScopeStructure(p)