Introduce components for library-to-source resolution in IDE

#KT-24309 In progress

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AbstractResolverForProject.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.AnchorProvider
 
 abstract class AbstractResolverForProject<M : ModuleInfo>(
     private val debugName: String,
@@ -21,7 +22,8 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
     modules: Collection<M>,
     protected val fallbackModificationTracker: ModificationTracker? = null,
     private val delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
-    private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory
+    private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory,
+    protected val anchorProvider: AnchorProvider = AnchorProvider.Default,
 ) : ResolverForProject<M>() {
 
     protected class ModuleData(
@@ -54,6 +56,13 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
     abstract fun modulesContent(module: M): ModuleContent<M>
     abstract fun builtInsForModule(module: M): KotlinBuiltIns
     abstract fun createResolverForModule(descriptor: ModuleDescriptor, moduleInfo: M): ResolverForModule
+    
+    protected open fun registerModuleDescriptorUpdate(
+        newDescriptor: ModuleDescriptor,
+        oldDescriptor: ModuleDescriptor?,
+    ) {
+        // Nothing by default 
+    }
 
     override fun tryGetResolverForModule(moduleInfo: M): ResolverForModule? {
         if (!isCorrectModuleInfo(moduleInfo)) {
@@ -62,6 +71,9 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
         return resolverForModuleDescriptor(doGetDescriptorForModule(moduleInfo))
     }
 
+    override fun tryGetResolverForModuleWithAnchorCheck(targetModuleInfo: M, referencingModuleInfo: M): ResolverForModule? =
+        tryGetResolverForModule(targetModuleInfo)
+
     private fun setupModuleDescriptor(module: M, moduleDescriptor: ModuleDescriptorImpl) {
         moduleDescriptor.setDependencies(
             LazyModuleDependencies(
@@ -122,6 +134,10 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
         return doGetDescriptorForModule(moduleInfo)
     }
 
+    override fun moduleInfoForModuleDescriptor(moduleDescriptor: ModuleDescriptor): M {
+        return moduleInfoByDescriptor[moduleDescriptor] ?: delegateResolver.moduleInfoForModuleDescriptor(moduleDescriptor)
+    }
+
     override fun diagnoseUnknownModuleInfo(infos: List<ModuleInfo>): Nothing {
         DiagnoseUnknownModuleInfoReporter.report(name, infos, allModules)
     }
@@ -142,6 +158,8 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
             }
             if (moduleData.isOutOfDate()) {
                 moduleData = recreateModuleDescriptor(moduleFromThisResolver)
+            } else {
+                registerModuleDescriptorUpdate(moduleData.moduleDescriptor, null)
             }
             moduleData.moduleDescriptor
         }
@@ -158,6 +176,9 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
 
         val moduleData = createModuleDescriptor(module)
         descriptorByModule[module] = moduleData
+        
+        registerModuleDescriptorUpdate(moduleData.moduleDescriptor, oldDescriptor)
+        
         return moduleData
     }
 
@@ -168,7 +189,8 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
             builtInsForModule(module),
             module.platform,
             module.capabilities,
-            module.stableName
+            module.stableName,
+            anchorProvider
         )
         moduleInfoByDescriptor[moduleDescriptor] = module
         setupModuleDescriptor(module, moduleDescriptor)

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -43,7 +43,9 @@ class ResolverForModule(
 abstract class ResolverForProject<M : ModuleInfo> {
     fun resolverForModule(moduleInfo: M): ResolverForModule = resolverForModuleDescriptor(descriptorForModule(moduleInfo))
     abstract fun tryGetResolverForModule(moduleInfo: M): ResolverForModule?
+    abstract fun tryGetResolverForModuleWithAnchorCheck(targetModuleInfo: M, referencingModuleInfo: M): ResolverForModule?
     abstract fun descriptorForModule(moduleInfo: M): ModuleDescriptor
+    abstract fun moduleInfoForModuleDescriptor(moduleDescriptor: ModuleDescriptor): M
     abstract fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule
     abstract fun diagnoseUnknownModuleInfo(infos: List<ModuleInfo>): Nothing
 
@@ -73,6 +75,13 @@ class EmptyResolverForProject<M : ModuleInfo> : ResolverForProject<M>() {
     override fun descriptorForModule(moduleInfo: M) = diagnoseUnknownModuleInfo(listOf(moduleInfo))
     override val allModules: Collection<M> = listOf()
     override fun diagnoseUnknownModuleInfo(infos: List<ModuleInfo>) = throw IllegalStateException("Should not be called for $infos")
+
+    override fun tryGetResolverForModuleWithAnchorCheck(targetModuleInfo: M, referencingModuleInfo: M) =
+        diagnoseUnknownModuleInfo(listOf(targetModuleInfo))
+
+    override fun moduleInfoForModuleDescriptor(descriptor: ModuleDescriptor): M {
+        throw IllegalStateException("$descriptor is not contained in this resolver")
+    }
 }
 
 data class ModuleContent<out M : ModuleInfo>(

compiler/frontend/src/org/jetbrains/kotlin/analyzer/ModuleResolverTracker.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analyzer
+
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.project.Project
+
+open class ModuleResolverTracker<M : ModuleInfo> {
+    open fun registerModuleUpdate(
+        newModule: ModuleDescriptor,
+        oldModule: ModuleDescriptor?,
+        resolverForProject: ResolverForProject<M>
+    ) {
+    }
+    
+    open fun findResolverForProjectByModuleDescriptor(moduleDescriptor: ModuleDescriptor): ResolverForProject<M>? = null
+    
+    companion object {
+        val Default = ModuleResolverTracker<ModuleInfo>()
+
+        fun getInstance(project: Project): ModuleResolverTracker<*> =
+            ServiceManager.getService(project, ModuleResolverTracker::class.java) ?: Default
+    }
+}