Refactor: Do not pass rootScope to QualifiedExpressionResolver#processImportReference

compiler/frontend/src/org/jetbrains/kotlin/resolve/ImportDirectiveProcessor.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve
 
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.psi.JetImportDirective
@@ -32,10 +33,10 @@ public class ImportDirectiveProcessor(
 ) {
     public fun processImportReference(
             importDirective: JetImportDirective,
-            scope: JetScope,
+            moduleDescriptor: ModuleDescriptor,
-            shouldBeVisibleFrom: DeclarationDescriptor,
             trace: BindingTrace,
-            lookupMode: QualifiedExpressionResolver.LookupMode
+            lookupMode: QualifiedExpressionResolver.LookupMode,
+            allowClassesFromDefaultPackage: Boolean
     ): JetScope {
         if (importDirective.isAbsoluteInRootPackage()) {
             trace.report(Errors.UNSUPPORTED.on(importDirective, "TypeHierarchyResolver")) // TODO
@@ -44,16 +45,17 @@ public class ImportDirectiveProcessor(
 
         val importedReference = importDirective.getImportedReference() ?: return JetScope.Empty
 
+        val scope = JetModuleUtil.getImportsResolutionScope(moduleDescriptor, allowClassesFromDefaultPackage)
         val descriptors = if (importedReference is JetQualifiedExpression) {
             //store result only when we find all descriptors, not only classes on the second phase
             qualifiedExpressionResolver.lookupDescriptorsForQualifiedExpression(
-                    importedReference, scope, shouldBeVisibleFrom, trace, lookupMode, lookupMode.isEverything()
+                    importedReference, scope, moduleDescriptor, trace, lookupMode, lookupMode.isEverything()
             )
         }
         else {
             assert(importedReference is JetSimpleNameExpression)
             qualifiedExpressionResolver.lookupDescriptorsForSimpleNameReference(
-                    importedReference as JetSimpleNameExpression, scope, shouldBeVisibleFrom, trace, lookupMode, true, lookupMode.isEverything()
+                    importedReference as JetSimpleNameExpression, scope, moduleDescriptor, trace, lookupMode, true, lookupMode.isEverything()
             )
         }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java

@@ -74,12 +74,12 @@ public class QualifiedExpressionResolver {
     @NotNull
     public JetScope processImportReference(
             @NotNull JetImportDirective importDirective,
-            @NotNull JetScope scope,
             @NotNull ModuleDescriptor moduleDescriptor,
             @NotNull BindingTrace trace,
-            @NotNull LookupMode lookupMode
+            @NotNull LookupMode lookupMode,
+            boolean allowClassesFromDefaultPackage
     ) {
-        return importDirectiveProcessor.processImportReference(importDirective, scope, moduleDescriptor, trace, lookupMode);
+        return importDirectiveProcessor.processImportReference(importDirective, moduleDescriptor, trace, lookupMode, allowClassesFromDefaultPackage);
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetImportDirective
 import org.jetbrains.kotlin.psi.JetPsiUtil
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.JetModuleUtil
 import org.jetbrains.kotlin.resolve.PlatformTypesMappedToKotlinChecker
 import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -69,12 +68,11 @@ class LazyImportResolver(
         val moduleDescriptor: ModuleDescriptor,
         val indexedImports: IndexedImports,
         private val traceForImportResolve: BindingTrace,
-        includeRootPackageClasses: Boolean
+        private val includeRootPackageClasses: Boolean
 ) {
     private val importedScopesProvider = resolveSession.getStorageManager().createMemoizedFunction {
         directive: JetImportDirective -> ImportDirectiveResolveCache(directive)
     }
-    private val rootScope = JetModuleUtil.getImportsResolutionScope(resolveSession.getModuleDescriptor(), includeRootPackageClasses)
 
     private var directiveUnderResolve: JetImportDirective? = null
 
@@ -101,7 +99,7 @@ class LazyImportResolver(
                     try {
                         val resolver = resolveSession.getQualifiedExpressionResolver()
                         val directiveImportScope = resolver.processImportReference(
-                                directive, rootScope, moduleDescriptor, traceForImportResolve, mode)
+                                directive, moduleDescriptor, traceForImportResolve, mode, includeRootPackageClasses)
                         val descriptors = if (directive.isAllUnder()) emptyList() else directiveImportScope.getAllDescriptors()
 
                         if (mode == LookupMode.EVERYTHING) {
@@ -211,11 +209,6 @@ class LazyImportResolver(
     public fun getImportScope(directive: JetImportDirective, lookupMode: LookupMode): JetScope {
         return importedScopesProvider(directive).scopeForMode(lookupMode)
     }
-
-    public fun printScopeStructure(p: Printer) {
-        p.print("rootScope = ")
-        rootScope.printScopeStructure(p.withholdIndentOnce())
-    }
 }
 
 class LazyImportScope(
@@ -296,8 +289,6 @@ class LazyImportScope(
 
         p.println("containingDeclaration = ", containingDeclaration)
 
-        importResolver.printScopeStructure(p)
-
         p.popIndent()
         p.println("}")
     }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt

@@ -225,10 +225,9 @@ private class ResolutionFacadeImpl(private val project: Project, private val cac
     override fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName, isDefaultImport: Boolean): Collection<DeclarationDescriptor> {
         val importDirective = JetPsiFactory(project).createImportDirective(ImportPath(fqName, false))
         val resolveSession = cache.getLazyResolveSession(moduleDescriptor)
-        val scope = JetModuleUtil.getImportsResolutionScope(moduleDescriptor, !isDefaultImport)
         val resolver = resolveSession.getQualifiedExpressionResolver()
         return resolver.processImportReference(
-                importDirective, moduleDescriptor, scope, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING).getAllDescriptors()
+                importDirective, moduleDescriptor, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING, !isDefaultImport).getAllDescriptors()
     }
 
     override fun <T> get(extension: CacheExtension<T>): T {