KotlinCacheService: allow to get ResolveSessionForBodies by module descriptor

Utility to resolve import in file by fq name

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

@@ -71,10 +71,9 @@ public class KotlinCacheService(val project: Project) {
                 return cache.getLazyResolveSession(file).getScopeProvider().getFileScope(file)
             }
 
-            override fun resolveImportReference(file: JetFile, fqName: FqName, isDefaultImport: Boolean): Collection<DeclarationDescriptor> {
+            override fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName, isDefaultImport: Boolean): Collection<DeclarationDescriptor> {
                 val importDirective = JetPsiFactory(project).createImportDirective(ImportPath(fqName, false))
-                val moduleDescriptor = findModuleDescriptor(file)
-                val resolveSession = cache.getLazyResolveSession(file)
+                val resolveSession = cache.getLazyResolveSession(moduleDescriptor)
                 val scope = JetModuleUtil.getImportsResolutionScope(moduleDescriptor, !isDefaultImport)
                 val resolver = resolveSession.getQualifiedExpressionResolver()
                 return resolver.processImportReference(

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

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.context.SimpleGlobalContext
 import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.di.InjectorForLazyBodyResolve
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
@@ -67,6 +68,10 @@ private class KotlinResolveCache(
         return moduleResolverProvider.resolveSessionForBodiesByModule(element.getModuleInfo())
     }
 
+    public fun getLazyResolveSession(moduleDescriptor: ModuleDescriptor): ResolveSessionForBodies {
+        return moduleResolverProvider.resolveSessionForBodiesByDescriptor(moduleDescriptor)
+    }
+
     public fun <T> get(extension: CacheExtension<T>): T {
         return extension.getData(moduleResolverProvider)
     }

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

@@ -24,6 +24,7 @@ import com.intellij.openapi.roots.ModuleRootManager
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.context.GlobalContextImpl
 import org.jetbrains.kotlin.context.withProject
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
@@ -69,14 +70,15 @@ fun createModuleResolverProvider(
 
     val resolverForProject = createResolverForProject()
 
-    val moduleToBodiesResolveSession = modulesToCreateResolversFor.keysToMap {
-        module ->
-        val analyzer = resolverForProject.resolverForModule(module)
+    val moduleDescriptors = modulesToCreateResolversFor.map { resolverForProject.descriptorForModule(it) }
+    val resolveSessionsForBodyByDescriptor = moduleDescriptors.keysToMap {
+        descriptor ->
+        val analyzer = resolverForProject.resolverForModuleDescriptor(descriptor)
         ResolveSessionForBodies(project, analyzer.lazyResolveSession)
     }
     return ModuleResolverProviderImpl(
             resolverForProject,
-            moduleToBodiesResolveSession,
+            resolveSessionsForBodyByDescriptor,
             globalContext,
             delegateProvider
     )
@@ -110,7 +112,12 @@ private fun collectAllModuleInfosFromIdeaModel(project: Project): List<IdeaModul
 trait ModuleResolverProvider {
     val exceptionTracker: ExceptionTracker
     fun resolverByModule(module: IdeaModuleInfo): ResolverForModule = resolverForProject.resolverForModule(module)
-    fun resolveSessionForBodiesByModule(module: IdeaModuleInfo): ResolveSessionForBodies
+
+    fun resolveSessionForBodiesByModule(module: IdeaModuleInfo): ResolveSessionForBodies {
+        return resolveSessionForBodiesByDescriptor(resolverForProject.descriptorForModule(module))
+    }
+
+    fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSessionForBodies
     val resolverForProject: ResolverForProject<IdeaModuleInfo, ResolverForModule>
 }
 
@@ -118,22 +125,23 @@ object EmptyModuleResolverProvider: ModuleResolverProvider {
     override val exceptionTracker: ExceptionTracker
         get() = throw IllegalStateException("Should not be called")
 
-    override fun resolveSessionForBodiesByModule(module: IdeaModuleInfo): ResolveSessionForBodies
-            = throw IllegalStateException("Trying to obtain resolve session for unknown $module")
-
     override val resolverForProject: ResolverForProject<IdeaModuleInfo, ResolverForModule> = EmptyResolverForProject()
 
+    override fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSessionForBodies {
+        throw IllegalStateException("Trying to obtain resolve session for $descriptor not present in this resolver")
+    }
 }
 
 class ModuleResolverProviderImpl(
         override val resolverForProject: ResolverForProject<IdeaModuleInfo, ResolverForModule>,
-        private val bodiesResolveByModule: Map<IdeaModuleInfo, ResolveSessionForBodies>,
+        private val bodiesResolveByDescriptor: Map<ModuleDescriptor, ResolveSessionForBodies>,
         val globalContext: GlobalContextImpl,
         val delegateProvider: ModuleResolverProvider = EmptyModuleResolverProvider
 ): ModuleResolverProvider {
     override val exceptionTracker: ExceptionTracker = globalContext.exceptionTracker
 
-    override fun resolveSessionForBodiesByModule(module: IdeaModuleInfo): ResolveSessionForBodies =
-            bodiesResolveByModule[module] ?:
-            delegateProvider.resolveSessionForBodiesByModule(module)
+    override fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSessionForBodies {
+        return bodiesResolveByDescriptor[descriptor] ?: delegateProvider.resolveSessionForBodiesByDescriptor(descriptor)
+    }
+
 }

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

@@ -37,8 +37,7 @@ public trait ResolutionFacade {
 
     public fun getFileTopLevelScope(file: JetFile): JetScope
 
-    //TODO: better pass ModuleDescriptor here
-    public fun resolveImportReference(file: JetFile, fqName: FqName, isDefaultImport: Boolean = false): Collection<DeclarationDescriptor>
+    public fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName, isDefaultImport: Boolean = false): Collection<DeclarationDescriptor>
 
     public fun findModuleDescriptor(element: JetElement): ModuleDescriptor
 

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.caches.resolve
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.psi.JetFile
@@ -33,6 +34,11 @@ public fun JetDeclaration.resolveToDescriptor(): DeclarationDescriptor {
     return getResolutionFacade().resolveToDescriptor(this)
 }
 
+public fun JetFile.resolveImportReference(fqName: FqName, isDefaultImport: Boolean = false): Collection<DeclarationDescriptor> {
+    val facade = getResolutionFacade()
+    return facade.resolveImportReference(facade.findModuleDescriptor(this), fqName, isDefaultImport)
+}
+
 //NOTE: the difference between analyze and analyzeFully is 'intentionally' unclear
 // in theory they do the same thing via different code
 // analyze - see ResolveSessionForBodies, ResolveElementCache