org.jetbrains.kotlin.analyzer.AnalyzerFacade.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of kotlin-compiler-embeddable Show documentation
Show all versions of kotlin-compiler-embeddable Show documentation
the Kotlin compiler embeddable
/*
* Copyright 2010-2024 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 com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.config.LanguageVersionSettings
import org.jetbrains.kotlin.container.ComponentProvider
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
import org.jetbrains.kotlin.descriptors.impl.ModuleDependencies
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.resolve.SealedClassInheritorsProvider
import org.jetbrains.kotlin.resolve.lazy.AbsentDescriptorHandler
import org.jetbrains.kotlin.resolve.scopes.optimization.OptimizingOptions
import org.jetbrains.kotlin.storage.StorageManager
import org.jetbrains.kotlin.storage.getValue
class ResolverForModule(
val packageFragmentProvider: PackageFragmentProvider,
val componentProvider: ComponentProvider
)
abstract class ResolverForProject {
fun resolverForModule(moduleInfo: M): ResolverForModule = resolverForModuleDescriptor(descriptorForModule(moduleInfo))
abstract fun tryGetResolverForModule(moduleInfo: 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): Nothing
abstract val name: String
abstract val allModules: Collection
override fun toString() = name
companion object {
const val resolverForSdkName = "sdk"
const val resolverForLibrariesName = "project libraries"
const val resolverForModulesName = "project source roots and libraries"
const val resolverForScriptDependenciesName = "dependencies of scripts"
const val resolverForSpecialInfoName = "completion/highlighting in "
}
}
class EmptyResolverForProject : ResolverForProject() {
override val name: String
get() = "Empty resolver"
override fun tryGetResolverForModule(moduleInfo: M): ResolverForModule? = null
override fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule =
throw IllegalStateException("$descriptor is not contained in this resolver")
override fun descriptorForModule(moduleInfo: M) = diagnoseUnknownModuleInfo(listOf(moduleInfo))
override val allModules: Collection = listOf()
override fun diagnoseUnknownModuleInfo(infos: List) = throw IllegalStateException("Should not be called for $infos")
override fun moduleInfoForModuleDescriptor(moduleDescriptor: ModuleDescriptor): M {
throw IllegalStateException("$moduleDescriptor is not contained in this resolver")
}
}
data class ModuleContent(
val moduleInfo: M,
val syntheticFiles: Collection,
val moduleContentScope: GlobalSearchScope
)
abstract class ResolverForModuleFactory {
open fun createResolverForModule(
moduleDescriptor: ModuleDescriptorImpl,
moduleContext: ModuleContext,
moduleContent: ModuleContent,
resolverForProject: ResolverForProject,
languageVersionSettings: LanguageVersionSettings,
sealedInheritorsProvider: SealedClassInheritorsProvider,
resolveOptimizingOptions: OptimizingOptions?,
absentDescriptorHandlerClass: Class?
): ResolverForModule {
@Suppress("DEPRECATION")
return createResolverForModule(
moduleDescriptor,
moduleContext,
moduleContent,
resolverForProject,
languageVersionSettings,
sealedInheritorsProvider,
resolveOptimizingOptions
)
}
@Deprecated(
"Left only for compatibility, please use full version",
ReplaceWith("createResolverForModule(moduleDescriptor, moduleContext, moduleContent, resolverForProject, languageVersionSettings, sealedInheritorsProvider, null, null)")
)
open fun createResolverForModule(
moduleDescriptor: ModuleDescriptorImpl,
moduleContext: ModuleContext,
moduleContent: ModuleContent,
resolverForProject: ResolverForProject,
languageVersionSettings: LanguageVersionSettings,
sealedInheritorsProvider: SealedClassInheritorsProvider,
resolveOptimizingOptions: OptimizingOptions?,
): ResolverForModule {
@Suppress("DEPRECATION")
return createResolverForModule(
moduleDescriptor,
moduleContext,
moduleContent,
resolverForProject,
languageVersionSettings,
sealedInheritorsProvider
)
}
@Deprecated(
"Left only for compatibility, please use full version",
ReplaceWith("createResolverForModule(moduleDescriptor, moduleContext, moduleContent, resolverForProject, languageVersionSettings, sealedInheritorsProvider, null, null)")
)
open fun createResolverForModule(
moduleDescriptor: ModuleDescriptorImpl,
moduleContext: ModuleContext,
moduleContent: ModuleContent,
resolverForProject: ResolverForProject,
languageVersionSettings: LanguageVersionSettings,
sealedInheritorsProvider: SealedClassInheritorsProvider
): ResolverForModule {
return createResolverForModule(
moduleDescriptor,
moduleContext,
moduleContent,
resolverForProject,
languageVersionSettings,
sealedInheritorsProvider,
resolveOptimizingOptions = null,
absentDescriptorHandlerClass = null
)
}
}
class LazyModuleDependencies(
storageManager: StorageManager,
private val module: M,
firstDependency: M?,
private val resolverForProject: AbstractResolverForProject
) : ModuleDependencies {
private val dependencies = storageManager.createLazyValue {
val moduleDescriptors = mutableSetOf()
firstDependency?.let {
module.assertModuleDependencyIsCorrect(it)
moduleDescriptors.add(resolverForProject.descriptorForModule(it))
}
val moduleDescriptor = resolverForProject.descriptorForModule(module)
val dependencyOnBuiltIns = module.dependencyOnBuiltIns()
if (dependencyOnBuiltIns == ModuleInfo.DependencyOnBuiltIns.AFTER_SDK) {
val builtInsModule = moduleDescriptor.builtIns.builtInsModule
module.assertModuleDependencyIsCorrect(builtInsModule)
moduleDescriptors.add(builtInsModule)
}
for (dependency in module.dependencies()) {
if (dependency == firstDependency) continue
module.assertModuleDependencyIsCorrect(dependency)
@Suppress("UNCHECKED_CAST")
moduleDescriptors.add(resolverForProject.descriptorForModule(dependency as M))
}
if (dependencyOnBuiltIns == ModuleInfo.DependencyOnBuiltIns.LAST) {
val builtInsModule = moduleDescriptor.builtIns.builtInsModule
module.assertModuleDependencyIsCorrect(builtInsModule)
moduleDescriptors.add(builtInsModule)
}
moduleDescriptors.toList()
}
override val allDependencies: List get() = dependencies()
override val directExpectedByDependencies by storageManager.createLazyValue {
module.expectedBy.map {
module.assertModuleDependencyIsCorrect(it)
@Suppress("UNCHECKED_CAST")
resolverForProject.descriptorForModule(it as M)
}
}
override val allExpectedByDependencies: Set by storageManager.createLazyValue {
collectAllExpectedByModules(module).mapTo(HashSet()) {
module.assertModuleDependencyIsCorrect(it)
@Suppress("UNCHECKED_CAST")
resolverForProject.descriptorForModule(it as M)
}
}
override val modulesWhoseInternalsAreVisible: Set
get() =
module.modulesWhoseInternalsAreVisible().mapTo(LinkedHashSet()) {
module.assertModuleDependencyIsCorrect(it)
@Suppress("UNCHECKED_CAST")
resolverForProject.descriptorForModule(it as M)
}
companion object {
private fun ModuleInfo.assertModuleDependencyIsCorrect(dependency: ModuleDescriptor) {
assertModuleDependencyIsCorrect(dependency.getCapability(ModuleInfo.Capability) ?: return)
}
private fun ModuleInfo.assertModuleDependencyIsCorrect(dependency: ModuleInfo) {
assert(dependency !is DerivedModuleInfo || this is DerivedModuleInfo) {
"Derived module infos may not be referenced from regular ones"
}
}
}
}