Changes after review

- Replace leaking ModuleResolverTracker with use of ModuleDescriptor.Capabilies
- Provide API for retrieving ResolverForProject from ResolutionFacade
- Update names

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/descriptors/FirModuleDescriptor.kt

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
-import org.jetbrains.kotlin.resolve.AnchorProvider
 
 class FirModuleDescriptor(val session: FirSession) : ModuleDescriptor {
     override val builtIns: KotlinBuiltIns
@@ -58,9 +57,6 @@ class FirModuleDescriptor(val session: FirSession) : ModuleDescriptor {
 
     }
 
-    override val anchorProvider: AnchorProvider
-        get() = AnchorProvider.Default
-
     override fun getOriginal(): DeclarationDescriptor {
         return this
     }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmResolverForModuleFactory.kt

@@ -70,7 +70,7 @@ class JvmResolverForModuleFactory(
 
             @Suppress("UNCHECKED_CAST")
             val resolverForReferencedModule = referencedClassModule?.let { 
-                resolverForProject.tryGetResolverForModuleWithAnchorCheck(it as M, moduleInfo)
+                resolverForProject.tryGetResolverForModuleWithResolutionAnchorFallback(it as M, moduleInfo)
             }
 
             val resolverForModule = resolverForReferencedModule?.takeIf {

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

@@ -14,7 +14,8 @@ 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
+import org.jetbrains.kotlin.resolve.RESOLUTION_ANCHOR_PROVIDER_CAPABILITY
+import org.jetbrains.kotlin.resolve.ResolutionAnchorProvider
 
 abstract class AbstractResolverForProject<M : ModuleInfo>(
     private val debugName: String,
@@ -23,7 +24,7 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
     protected val fallbackModificationTracker: ModificationTracker? = null,
     private val delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
     private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory,
-    protected val anchorProvider: AnchorProvider = AnchorProvider.Default,
+    protected val resolutionAnchorProvider: ResolutionAnchorProvider = ResolutionAnchorProvider.Default,
 ) : ResolverForProject<M>() {
 
     protected class ModuleData(
@@ -56,14 +57,6 @@ 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)) {
             return null
@@ -71,7 +64,7 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
         return resolverForModuleDescriptor(doGetDescriptorForModule(moduleInfo))
     }
 
-    override fun tryGetResolverForModuleWithAnchorCheck(targetModuleInfo: M, referencingModuleInfo: M): ResolverForModule? =
+    override fun tryGetResolverForModuleWithResolutionAnchorFallback(targetModuleInfo: M, referencingModuleInfo: M): ResolverForModule? =
         tryGetResolverForModule(targetModuleInfo)
 
     private fun setupModuleDescriptor(module: M, moduleDescriptor: ModuleDescriptorImpl) {
@@ -158,8 +151,6 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
             }
             if (moduleData.isOutOfDate()) {
                 moduleData = recreateModuleDescriptor(moduleFromThisResolver)
-            } else {
-                registerModuleDescriptorUpdate(moduleData.moduleDescriptor, null)
             }
             moduleData.moduleDescriptor
         }
@@ -176,9 +167,7 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
 
         val moduleData = createModuleDescriptor(module)
         descriptorByModule[module] = moduleData
-        
-        registerModuleDescriptorUpdate(moduleData.moduleDescriptor, oldDescriptor)
-        
+
         return moduleData
     }
 
@@ -188,9 +177,8 @@ abstract class AbstractResolverForProject<M : ModuleInfo>(
             projectContext.storageManager,
             builtInsForModule(module),
             module.platform,
-            module.capabilities,
+            module.capabilities + listOf(RESOLUTION_ANCHOR_PROVIDER_CAPABILITY to resolutionAnchorProvider),
             module.stableName,
-            anchorProvider
         )
         moduleInfoByDescriptor[moduleDescriptor] = module
         setupModuleDescriptor(module, moduleDescriptor)

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

@@ -43,7 +43,7 @@ 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 tryGetResolverForModuleWithResolutionAnchorFallback(targetModuleInfo: M, referencingModuleInfo: M): ResolverForModule?
     abstract fun descriptorForModule(moduleInfo: M): ModuleDescriptor
     abstract fun moduleInfoForModuleDescriptor(moduleDescriptor: ModuleDescriptor): M
     abstract fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule
@@ -76,7 +76,7 @@ class EmptyResolverForProject<M : ModuleInfo> : ResolverForProject<M>() {
     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) =
+    override fun tryGetResolverForModuleWithResolutionAnchorFallback(targetModuleInfo: M, referencingModuleInfo: M) =
         diagnoseUnknownModuleInfo(listOf(targetModuleInfo))
 
     override fun moduleInfoForModuleDescriptor(descriptor: ModuleDescriptor): M {

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

@@ -1,28 +0,0 @@
-/*
- * 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
-    }
-}

core/descriptors/src/org/jetbrains/kotlin/descriptors/ModuleDescriptor.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
-import org.jetbrains.kotlin.resolve.AnchorProvider
 
 interface ModuleDescriptor : DeclarationDescriptor {
     override fun getContainingDeclaration(): DeclarationDescriptor? = null
@@ -62,6 +61,4 @@ interface ModuleDescriptor : DeclarationDescriptor {
     val isValid: Boolean
 
     fun assertValid()
-
-    val anchorProvider: AnchorProvider
 }

core/descriptors/src/org/jetbrains/kotlin/descriptors/findClassInModule.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.descriptors
 
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.resolve.RESOLUTION_ANCHOR_PROVIDER_CAPABILITY
 
 fun ModuleDescriptor.findClassifierAcrossModuleDependencies(classId: ClassId): ClassifierDescriptor? = withAnchorFallback {
     val packageViewDescriptor = getPackage(classId.packageFqName)
@@ -39,7 +40,7 @@ fun ModuleDescriptor.findClassifierAcrossModuleDependencies(classId: ClassId): C
 private inline fun ModuleDescriptor.withAnchorFallback(
     crossinline doSearch: ModuleDescriptor.() -> ClassifierDescriptor? 
 ): ClassifierDescriptor? {
-    val anchor = anchorProvider.getAnchor(this)
+    val anchor = getCapability(RESOLUTION_ANCHOR_PROVIDER_CAPABILITY)?.getResolutionAnchor(this)
     return if (anchor == null) doSearch() else doSearch() ?: anchor.doSearch()
 }
 

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
-import org.jetbrains.kotlin.resolve.AnchorProvider
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.checker.REFINER_CAPABILITY
 import org.jetbrains.kotlin.types.checker.Ref
@@ -40,7 +39,6 @@ class ModuleDescriptorImpl @JvmOverloads constructor(
     override val platform: TargetPlatform? = null,
     capabilities: Map<ModuleDescriptor.Capability<*>, Any?> = emptyMap(),
     override val stableName: Name? = null,
-    override val anchorProvider: AnchorProvider = AnchorProvider.Default,
 ) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor {
     private val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>
 

core/descriptors/src/org/jetbrains/kotlin/resolve/AnchorProvider.kt

@@ -1,14 +0,0 @@
-/*
- * 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.resolve
-
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-
-abstract class AnchorProvider {
-    open fun getAnchor(moduleDescriptor: ModuleDescriptor): ModuleDescriptor? = null
-    
-    companion object Default : AnchorProvider()
-}

core/descriptors/src/org/jetbrains/kotlin/resolve/ResolutionAnchorProvider.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.resolve
+
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+
+interface ResolutionAnchorProvider {
+    fun getResolutionAnchor(moduleDescriptor: ModuleDescriptor): ModuleDescriptor? = null
+
+    companion object {
+        val Default: ResolutionAnchorProvider = object : ResolutionAnchorProvider {
+            override fun getResolutionAnchor(moduleDescriptor: ModuleDescriptor): ModuleDescriptor? = null
+        }
+    }
+}
+
+val RESOLUTION_ANCHOR_PROVIDER_CAPABILITY = ModuleDescriptor.Capability<ResolutionAnchorProvider>("ResolutionAnchorProvider")

core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java

@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.platform.TargetPlatform;
-import org.jetbrains.kotlin.resolve.AnchorProvider;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.kotlin.resolve.scopes.MemberScope;
@@ -54,12 +53,6 @@ public class ErrorUtils {
 
     static {
         ERROR_MODULE = new ModuleDescriptor() {
-            @NotNull
-            @Override
-            public AnchorProvider getAnchorProvider() {
-                return AnchorProvider.Default;
-            }
-
             @Nullable
             @Override
             public <T> T getCapability(@NotNull Capability<T> capability) {

idea/ide-common/src/org/jetbrains/kotlin/idea/resolve/ResolutionFacade.kt

@@ -8,6 +8,8 @@ package org.jetbrains.kotlin.idea.resolve
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.analyzer.ResolverForProject
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.psi.KtDeclaration
@@ -38,6 +40,7 @@ interface ResolutionFacade {
 
     fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T
 
+    fun getResolverForProject(): ResolverForProject<out ModuleInfo>
 }
 
 inline fun <reified T : Any> ResolutionFacade.frontendService(): T = this.getFrontendService(T::class.java)

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

@@ -1,38 +0,0 @@
-/*
- * 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.idea.caches.resolve
-
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analyzer.ModuleResolverTracker
-import org.jetbrains.kotlin.analyzer.ResolverForProject
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
-import org.jetbrains.kotlin.idea.project.useAnchorServices
-
-class IdeaModuleResolverTrackerImpl(private val project: Project) : ModuleResolverTracker<IdeaModuleInfo>() {
-    private val resolversForModules by lazy {
-        mutableMapOf<ModuleDescriptor, ResolverForProject<IdeaModuleInfo>>()
-    }
-    
-    @Synchronized
-    override fun registerModuleUpdate(
-        newModule: ModuleDescriptor,
-        oldModule: ModuleDescriptor?,
-        resolverForProject: ResolverForProject<IdeaModuleInfo>
-    ) {
-        if (!project.useAnchorServices) return
-        
-        if (oldModule != null) resolversForModules.remove(oldModule)
-        resolversForModules[newModule] = resolverForProject
-    }
-
-    @Synchronized
-    override fun findResolverForProjectByModuleDescriptor(moduleDescriptor: ModuleDescriptor): ResolverForProject<IdeaModuleInfo>? {
-        if (!project.useAnchorServices) return null
-        
-        return resolversForModules[moduleDescriptor]
-    }
-}

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
 import org.jetbrains.kotlin.caches.resolve.CompositeAnalyzerServices
 import org.jetbrains.kotlin.caches.resolve.CompositeResolverForModuleFactory
+import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.caches.resolve.resolution
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.context.withModule
@@ -32,7 +33,7 @@ import org.jetbrains.kotlin.platform.isCommon
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.platform.jvm.isJvm
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.AnchorProvider
+import org.jetbrains.kotlin.resolve.ResolutionAnchorProvider
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
@@ -53,7 +54,7 @@ class IdeaResolverForProject(
     fallbackModificationTracker,
     delegateResolver,
     ServiceManager.getService(projectContext.project, IdePackageOracleFactory::class.java),
-    ServiceManager.getService(projectContext.project, AnchorProvider::class.java)
+    ServiceManager.getService(projectContext.project, ResolutionAnchorProvider::class.java)
 ) {
     private val builtInsCache: BuiltInsCache =
         (delegateResolver as? IdeaResolverForProject)?.builtInsCache ?: BuiltInsCache(projectContext, this)
@@ -149,32 +150,32 @@ class IdeaResolverForProject(
         }
     }
 
-    override fun registerModuleDescriptorUpdate(
-        newDescriptor: ModuleDescriptor,
-        oldDescriptor: ModuleDescriptor?
-    ) {
-        ModuleResolverTracker
-            .getInstance(projectContext.project)
-            .safeAs<IdeaModuleResolverTrackerImpl>()
-            ?.registerModuleUpdate(newDescriptor, oldDescriptor, this)
-    }
-
-    override fun tryGetResolverForModuleWithAnchorCheck(
+    override fun tryGetResolverForModuleWithResolutionAnchorFallback(
         targetModuleInfo: IdeaModuleInfo,
         referencingModuleInfo: IdeaModuleInfo,
     ): ResolverForModule? {
         tryGetResolverForModule(targetModuleInfo)?.let { return it }
 
+        return getResolverForProjectUsingResolutionAnchor(targetModuleInfo, referencingModuleInfo)
+    }
+    
+    private fun getResolverForProjectUsingResolutionAnchor(
+        targetModuleInfo: IdeaModuleInfo, 
+        referencingModuleInfo: IdeaModuleInfo
+    ): ResolverForModule? {
         val moduleDescriptorOfReferencingModule = descriptorByModule[referencingModuleInfo]?.moduleDescriptor
             ?: error("$referencingModuleInfo is not contained in this resolver, which means incorrect use of anchor-aware search")
-        
-        val anchorModuleDescriptor = anchorProvider.getAnchor(moduleDescriptorOfReferencingModule) ?: return null
-        
-        val moduleResolverTracker = 
-            ModuleResolverTracker.getInstance(projectContext.project).safeAs<IdeaModuleResolverTrackerImpl>() ?: return null
-        
-        return moduleResolverTracker.findResolverForProjectByModuleDescriptor(anchorModuleDescriptor)
-            ?.tryGetResolverForModule(targetModuleInfo)
+
+        val anchorModuleInfo = resolutionAnchorProvider.getResolutionAnchor(moduleDescriptorOfReferencingModule)?.moduleInfo ?: return null
+
+        val resolverForProjectFromAnchorModule = KotlinCacheService.getInstance(projectContext.project)
+            .getResolutionFacadeByModuleInfo(anchorModuleInfo, anchorModuleInfo.platform)
+            ?.getResolverForProject()
+            ?: return null
+
+        if (resolverForProjectFromAnchorModule !is IdeaResolverForProject) return null
+
+        return resolverForProjectFromAnchorModule.tryGetResolverForModule(targetModuleInfo)
     }
 }
 

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

@@ -12,23 +12,25 @@ import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.project.Project
 import com.intellij.util.xmlb.XmlSerializerUtil
 import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.analyzer.ModuleResolverTracker
+import org.jetbrains.kotlin.analyzer.moduleInfo
 import org.jetbrains.kotlin.caches.project.cacheInvalidatingOnRootModifications
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.caches.project.*
-import org.jetbrains.kotlin.idea.project.useAnchorServices
-import org.jetbrains.kotlin.resolve.AnchorProvider
+import org.jetbrains.kotlin.idea.project.libraryToSourceAnalysisEnabled
+import org.jetbrains.kotlin.resolve.ResolutionAnchorProvider
 
 @State(name = "KotlinIdeAnchorService", storages = [Storage("anchors.xml")])
-class KotlinIdeAnchorService(
+class KotlinIdeResolutionAnchorService(
     val project: Project
-) : AnchorProvider(), 
-    PersistentStateComponent<KotlinIdeAnchorService.State> {
+) : ResolutionAnchorProvider, 
+    PersistentStateComponent<KotlinIdeResolutionAnchorService.State> {
 
     data class State(
         var moduleNameToAnchorName: Map<String, String> = emptyMap()
     )
+    
+    private val logger = logger<KotlinIdeResolutionAnchorService>()
 
     @JvmField
     var myState: State = State()
@@ -50,7 +52,7 @@ class KotlinIdeAnchorService(
     }
     
     private fun notFoundModule(moduleName: String): Nothing? {
-        logger<KotlinIdeAnchorService>().warn("Module <${moduleName}> not found in project model")
+        logger.warn("Module <${moduleName}> not found in project model")
         return null
     }
 
@@ -59,13 +61,6 @@ class KotlinIdeAnchorService(
             buildMapping()
         }
 
-    private fun getAnchorModuleDescriptorIfAny(moduleInfo: ModuleInfo): ModuleDescriptor? {
-        val mapped = moduleToAnchor[moduleInfo] ?: return null
-        return KotlinCacheService.getInstance(project)
-            .getResolutionFacadeByModuleInfo(mapped, mapped.platform)
-            ?.moduleDescriptor
-    }
-
     @Synchronized
     override fun getState(): State = myState
 
@@ -75,11 +70,12 @@ class KotlinIdeAnchorService(
     }
 
     @Synchronized
-    override fun getAnchor(moduleDescriptor: ModuleDescriptor): ModuleDescriptor? {
-        if (!project.useAnchorServices) return null
-        val resolver = ModuleResolverTracker.getInstance(project)
-            .findResolverForProjectByModuleDescriptor(moduleDescriptor)
-            ?: return null
-        return getAnchorModuleDescriptorIfAny(resolver.moduleInfoForModuleDescriptor(moduleDescriptor))
+    override fun getResolutionAnchor(moduleDescriptor: ModuleDescriptor): ModuleDescriptor? {
+        if (!project.libraryToSourceAnalysisEnabled) return null
+        val moduleInfo = moduleDescriptor.moduleInfo ?: return null
+        val mapped = moduleToAnchor[moduleInfo] ?: return null
+        return KotlinCacheService.getInstance(project)
+            .getResolutionFacadeByModuleInfo(mapped, mapped.platform)
+            ?.moduleDescriptor
     }
 }

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

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.caches.resolve
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.analyzer.ResolverForProject
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.getService
 import org.jetbrains.kotlin.container.tryGetService
@@ -115,6 +116,10 @@ internal class ModuleResolutionFacadeImpl(
     override fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
         return projectFacade.resolverForDescriptor(moduleDescriptor).componentProvider.getService(serviceClass)
     }
+
+    override fun getResolverForProject(): ResolverForProject<IdeaModuleInfo> {
+        return projectFacade.getResolverForProject()
+    }
 }
 
 fun ResolutionFacade.findModuleDescriptor(ideaModuleInfo: IdeaModuleInfo): ModuleDescriptor {

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

@@ -145,6 +145,8 @@ internal class ProjectResolutionFacade(
     internal fun findModuleDescriptor(ideaModuleInfo: IdeaModuleInfo): ModuleDescriptor {
         return cachedResolverForProject.descriptorForModule(ideaModuleInfo)
     }
+    
+    internal fun getResolverForProject(): ResolverForProject<IdeaModuleInfo> = cachedResolverForProject
 
     internal fun getAnalysisResultsForElements(elements: Collection<KtElement>): AnalysisResult {
         assert(elements.isNotEmpty()) { "elements collection should not be empty" }

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

@@ -14,6 +14,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiNamedElement
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.analyzer.ResolverForProject
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
@@ -89,6 +90,10 @@ private class ResolutionFacadeWithDebugInfo(
         }
     }
 
+    override fun getResolverForProject(): ResolverForProject<out ModuleInfo> {
+        return delegate.getResolverForProject()
+    }
+
     override fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
         return wrapExceptions({ ResolvingWhat(serviceClass = serviceClass, moduleDescriptor = moduleDescriptor) }) {
             delegate.getFrontendService(moduleDescriptor, serviceClass)

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

@@ -6,10 +6,8 @@
 package org.jetbrains.kotlin.idea.caches.resolve.util
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.registry.Registry
 import org.jetbrains.kotlin.context.GlobalContextImpl
-import org.jetbrains.kotlin.idea.caches.resolve.PlatformAnalysisSettings
-import org.jetbrains.kotlin.idea.project.useAnchorServices
+import org.jetbrains.kotlin.idea.project.libraryToSourceAnalysisEnabled
 import org.jetbrains.kotlin.idea.project.useCompositeAnalysis
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.storage.ExceptionTracker
@@ -34,7 +32,7 @@ private fun GlobalContextImpl.contextWithNewLockAndCompositeExceptionTracker(deb
 }
 
 internal fun GlobalContextImpl.contextWithCompositeExceptionTracker(project: Project, debugName: String): GlobalContextImpl =
-    if (project.useCompositeAnalysis || project.useAnchorServices) {
+    if (project.useCompositeAnalysis || project.libraryToSourceAnalysisEnabled) {
         this.contextWithCompositeExceptionTracker(debugName)
     } else {
         this.contextWithNewLockAndCompositeExceptionTracker(debugName)

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/KotlinLibraryToSourceAnalysisComponent.kt

@@ -8,18 +8,18 @@ package org.jetbrains.kotlin.idea.project
 import com.intellij.ide.util.PropertiesComponent
 import com.intellij.openapi.project.Project
 
-object KotlinAnchorSupportForLibraryAnalysisComponent {
-    private const val anchorSupportOption = "kotlin.use.anchor.services"
+object KotlinLibraryToSourceAnalysisComponent {
+    private const val libraryToSourceAnalysisOption = "kotlin.library.to.source.analysis"
 
     @JvmStatic
     fun setState(project: Project, isEnabled: Boolean) {
-        PropertiesComponent.getInstance(project).setValue(anchorSupportOption, isEnabled, false)
+        PropertiesComponent.getInstance(project).setValue(libraryToSourceAnalysisOption, isEnabled, false)
     }
 
     @JvmStatic
     fun isEnabled(project: Project): Boolean =
-        PropertiesComponent.getInstance(project).getBoolean(anchorSupportOption)
+        PropertiesComponent.getInstance(project).getBoolean(libraryToSourceAnalysisOption)
 }
 
-val Project.useAnchorServices: Boolean
-    get() = KotlinAnchorSupportForLibraryAnalysisComponent.isEnabled(this)
+val Project.libraryToSourceAnalysisEnabled: Boolean
+    get() = KotlinLibraryToSourceAnalysisComponent.isEnabled(this)

idea/jvm-debugger/jvm-debugger-evaluation/src/org/jetbrains/kotlin/idea/debugger/evaluate/compilation/DebugLabelPropertyDescriptorProvider.kt

@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.externalDescriptors
-import org.jetbrains.kotlin.resolve.AnchorProvider
+import org.jetbrains.kotlin.resolve.ResolutionAnchorProvider
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.Variance
@@ -196,8 +196,6 @@ private object DebugLabelModuleDescriptor : DeclarationDescriptorImpl(Annotation
         get() = true
 
     override fun assertValid() {}
-    override val anchorProvider: AnchorProvider
-        get() = AnchorProvider.Default
 }
 
 internal class DebugLabelPropertyDescriptor(

idea/resources-en/messages/KotlinBundle.properties

@@ -1918,8 +1918,8 @@ signature.preview=Signature Preview
 move.members.from=Move members from:
 open.moved.members.in.editor=Open moved members in editor
 to.fully.qualified.name=To (fully qualified name):
-toggle.anchor.support.for.library.analysis=Toggle anchor support for library analysis
-enable.components.for.library.to.source.analysis.in.kotlin=Enable components for library-to-source analysis in Kotlin
+toggle.library.to.source.dependency.support=Toggle library to source dependency support
+enable.components.for.library.to.source.analysis.in.kotlin=Enable components for analyzing libraries depending on project source files in Kotlin
 
 action.Kotlin.StopScratch.text=Stop Scratch Execution
 action.Kotlin.StopScratch.description=Stop scratch execution
@@ -1975,7 +1975,7 @@ action.ShowKotlinBytecode.text=Show Kotlin Bytecode
 action.ConfigureKotlinJsInProject.text=Configure Kotlin (JavaScript) in Project
 action.ConfigureKotlinInProject.text=Configure Kotlin in Project
 action.KotlinConsoleREPL.text=Kotlin REPL
-action.AnchorSupportForLibraryAnalysisToggleAction.text=Toggle Anchor Support For Modules
+action.LibraryToSourceDependencySupportToggleAction.text=Toggle library to source dependency support
 
 inspection.unused.unary.operator.display.name=Unused unary operator
 inspection.replace.guard.clause.with.function.call.display.name=Replace guard clause with kotlin's function call

idea/resources/META-INF/plugin-common.xml

@@ -90,7 +90,7 @@
 
         <action id="MultiplatformCompositeAnalysisToggleAction" class="org.jetbrains.kotlin.idea.actions.internal.MultiplatformCompositeAnalysisToggleAction"/>
 
-        <action id="AnchorSupportForLibraryAnalysisToggleAction" class="org.jetbrains.kotlin.idea.actions.internal.AnchorSupportForLibraryAnalysisToggleAction"/>
+        <action id="LibraryToSourceDependencySupportToggleAction" class="org.jetbrains.kotlin.idea.actions.internal.LibraryToSourceDependencySupportToggleAction"/>
 
         <action id="CopyAsDiagnosticTest" class="org.jetbrains.kotlin.idea.actions.internal.CopyAsDiagnosticTestAction"/>
 
@@ -191,11 +191,8 @@
     <projectService serviceInterface="org.jetbrains.kotlin.caches.resolve.KotlinCacheService"
                     serviceImplementation="org.jetbrains.kotlin.idea.caches.resolve.KotlinCacheServiceImpl"/>
 
-    <projectService serviceInterface="org.jetbrains.kotlin.resolve.AnchorProvider"
-                    serviceImplementation="org.jetbrains.kotlin.idea.caches.resolve.KotlinIdeAnchorService"/>
-
-    <projectService serviceInterface="org.jetbrains.kotlin.analyzer.ModuleResolverTracker"
-                    serviceImplementation="org.jetbrains.kotlin.idea.caches.resolve.IdeaModuleResolverTrackerImpl"/>
+    <projectService serviceInterface="org.jetbrains.kotlin.resolve.ResolutionAnchorProvider"
+                    serviceImplementation="org.jetbrains.kotlin.idea.caches.resolve.KotlinIdeResolutionAnchorService"/>
 
     <projectService serviceInterface="org.jetbrains.kotlin.idea.fir.FirIdeResolveStateService"
                     serviceImplementation="org.jetbrains.kotlin.idea.fir.FirIdeResolveStateServiceImpl"/>

idea/src/org/jetbrains/kotlin/idea/actions/internal/LibraryToSourceDependencySupportToggleAction.kt

@@ -8,20 +8,20 @@ package org.jetbrains.kotlin.idea.actions.internal
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.actionSystem.ToggleAction
 import org.jetbrains.kotlin.idea.KotlinBundle
-import org.jetbrains.kotlin.idea.project.KotlinAnchorSupportForLibraryAnalysisComponent
-import org.jetbrains.kotlin.idea.project.useAnchorServices
+import org.jetbrains.kotlin.idea.project.KotlinLibraryToSourceAnalysisComponent
+import org.jetbrains.kotlin.idea.project.libraryToSourceAnalysisEnabled
 
-class AnchorSupportForLibraryAnalysisToggleAction : ToggleAction(
-    KotlinBundle.message("toggle.anchor.support.for.library.analysis"),
+class LibraryToSourceDependencySupportToggleAction : ToggleAction(
+    KotlinBundle.message("toggle.library.to.source.dependency.support"),
     KotlinBundle.message("enable.components.for.library.to.source.analysis.in.kotlin"),
     null
 ) {
     override fun isSelected(e: AnActionEvent): Boolean =
-        e.project?.useAnchorServices == true
+        e.project?.libraryToSourceAnalysisEnabled == true
 
     override fun setSelected(e: AnActionEvent, state: Boolean) {
         e.project?.let {
-            KotlinAnchorSupportForLibraryAnalysisComponent.setState(it, state)
+            KotlinLibraryToSourceAnalysisComponent.setState(it, state)
         }
     }
 

plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KotlinResolutionFacadeForRepl.kt

@@ -8,6 +8,8 @@ package org.jetbrains.kotlin.scripting.ide_services.compiler.impl
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.analyzer.ResolverForProject
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -50,6 +52,10 @@ class KotlinResolutionFacadeForRepl(
         throw UnsupportedOperationException()
     }
 
+    override fun getResolverForProject(): ResolverForProject<out ModuleInfo> {
+        throw UnsupportedOperationException()
+    }
+
     override fun <T : Any> getFrontendService(element: PsiElement, serviceClass: Class<T>): T {
         throw UnsupportedOperationException()
     }