Restructure the project to utilize included builds (#3174)

* Refactor and simplify artifact publishing
* Update Gradle to 8.4
* Refactor and simplify convention plugins and build scripts

Fixes #3132

---------

Co-authored-by: Adam <897017+aSemy@users.noreply.github.com>
Co-authored-by: Oleg Yukhnevich <whyoleg@gmail.com>

23 files changed, 1643 insertions, 0 deletions

diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/CoreKotlinCacheService.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/CoreKotlinCacheService.kt
new file mode 100644
index 00000000..2a299009
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/CoreKotlinCacheService.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
+import org.jetbrains.kotlin.caches.resolve.PlatformAnalysisSettings
+import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.resolve.diagnostics.KotlinSuppressCache
+
+
+internal class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade) : KotlinCacheService {
+    override fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacade(element: KtElement): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeByFile(
+        file: PsiFile,
+        platform: TargetPlatform
+    ): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeByModuleInfo(
+        moduleInfo: ModuleInfo,
+        settings: PlatformAnalysisSettings
+    ): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeByModuleInfo(
+        moduleInfo: ModuleInfo,
+        platform: TargetPlatform
+    ): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeWithForcedPlatform(
+        elements: List<KtElement>,
+        platform: TargetPlatform
+    ): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getSuppressionCache(): KotlinSuppressCache {
+        throw UnsupportedOperationException()
+    }
+
+}
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/DokkaResolutionFacade.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/DokkaResolutionFacade.kt
new file mode 100644
index 00000000..1ded0495
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/DokkaResolutionFacade.kt
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+@file:OptIn(FrontendInternals::class)
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import com.google.common.collect.ImmutableMap
+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.ResolverForModule
+import org.jetbrains.kotlin.analyzer.ResolverForProject
+import org.jetbrains.kotlin.container.getService
+import org.jetbrains.kotlin.container.tryGetService
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.diagnostics.DiagnosticSink
+import org.jetbrains.kotlin.idea.FrontendInternals
+import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
+import org.jetbrains.kotlin.util.slicedMap.WritableSlice
+
+internal class DokkaResolutionFacade(
+    override val project: Project,
+    override val moduleDescriptor: ModuleDescriptor,
+    val resolverForModule: ResolverForModule
+) : ResolutionFacade {
+    override fun analyzeWithAllCompilerChecks(
+        elements: Collection<KtElement>,
+        callback: DiagnosticSink.DiagnosticsCallback?
+    ): AnalysisResult {
+        throw UnsupportedOperationException()
+    }
+
+    @OptIn(FrontendInternals::class)
+    override fun <T : Any> tryGetFrontendService(element: PsiElement, serviceClass: Class<T>): T? {
+        return resolverForModule.componentProvider.tryGetService(serviceClass)
+    }
+
+    override fun resolveToDescriptor(
+        declaration: KtDeclaration,
+        bodyResolveMode: BodyResolveMode
+    ): DeclarationDescriptor {
+        return resolveSession.resolveToDescriptor(declaration)
+    }
+
+    override fun analyze(elements: Collection<KtElement>, bodyResolveMode: BodyResolveMode): BindingContext {
+        throw UnsupportedOperationException()
+    }
+
+    val resolveSession: ResolveSession get() = getFrontendService(ResolveSession::class.java)
+
+    override fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
+        if (element is KtDeclaration) {
+            val descriptor = resolveToDescriptor(element)
+            return object : BindingContext {
+                override fun <K : Any?, V : Any?> getKeys(p0: WritableSlice<K, V>?): Collection<K> {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun getType(p0: KtExpression): KotlinType? {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun <K : Any?, V : Any?> get(slice: ReadOnlySlice<K, V>?, key: K): V? {
+                    if (key != element) {
+                        throw UnsupportedOperationException()
+                    }
+                    @Suppress("UNCHECKED_CAST")
+                    return when {
+                        slice == BindingContext.DECLARATION_TO_DESCRIPTOR -> descriptor as V
+                        slice == BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER && (element as KtParameter).hasValOrVar() -> descriptor as V
+                        else -> null
+                    }
+                }
+
+                override fun getDiagnostics(): Diagnostics {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun addOwnDataTo(p0: BindingTrace, p1: Boolean) {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun <K : Any?, V : Any?> getSliceContents(p0: ReadOnlySlice<K, V>): ImmutableMap<K, V> {
+                    throw UnsupportedOperationException()
+                }
+
+            }
+        }
+        throw UnsupportedOperationException()
+    }
+
+    override fun <T : Any> getFrontendService(element: PsiElement, serviceClass: Class<T>): T {
+        throw UnsupportedOperationException()
+    }
+
+    override fun <T : Any> getFrontendService(serviceClass: Class<T>): T {
+        return resolverForModule.componentProvider.getService(serviceClass)
+    }
+
+    @Deprecated("DO NOT USE IT AS IT IS A ROOT CAUSE OF KTIJ-17649")
+    override fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
+        return resolverForModule.componentProvider.getService(serviceClass)
+    }
+
+    override fun <T : Any> getIdeService(serviceClass: Class<T>): T {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getResolverForProject(): ResolverForProject<out ModuleInfo> {
+        throw UnsupportedOperationException()
+    }
+
+}
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeAnalysisContextCreator.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeAnalysisContextCreator.kt
new file mode 100644
index 00000000..252fbd55
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeAnalysisContextCreator.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import com.intellij.mock.MockComponentManager
+import com.intellij.mock.MockProject
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.AnalysisContextCreator
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.configuration.AnalysisContext
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.configuration.AnalysisEnvironment
+import org.jetbrains.kotlin.analyzer.ResolverForModule
+import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+
+internal class IdeAnalysisContextCreator : AnalysisContextCreator {
+    override fun create(
+        project: MockProject,
+        moduleDescriptor: ModuleDescriptor,
+        moduleResolver: ResolverForModule,
+        kotlinEnvironment: KotlinCoreEnvironment,
+        analysisEnvironment: AnalysisEnvironment,
+    ): AnalysisContext {
+        val facade = DokkaResolutionFacade(project, moduleDescriptor, moduleResolver)
+        val projectComponentManager = project as MockComponentManager
+        projectComponentManager.registerService(
+            KotlinCacheService::class.java,
+            CoreKotlinCacheService(facade)
+        )
+        return ResolutionFacadeAnalysisContext(facade, kotlinEnvironment, analysisEnvironment)
+    }
+}
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeDescriptorAnalysisPlugin.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeDescriptorAnalysisPlugin.kt
new file mode 100644
index 00000000..e170b740
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeDescriptorAnalysisPlugin.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import org.jetbrains.dokka.InternalDokkaApi
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.CompilerDescriptorAnalysisPlugin
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.plugability.DokkaPluginApiPreview
+import org.jetbrains.dokka.plugability.PluginApiPreviewAcknowledgement
+
+@InternalDokkaApi
+public class IdeDescriptorAnalysisPlugin : DokkaPlugin() {
+
+    internal val ideKdocFinder by extending {
+        plugin<CompilerDescriptorAnalysisPlugin>().kdocFinder providing ::IdePluginKDocFinder
+    }
+
+    internal val ideDescriptorFinder by extending {
+        plugin<CompilerDescriptorAnalysisPlugin>().descriptorFinder providing { IdeDescriptorFinder() }
+    }
+
+    internal val ideKlibService by extending {
+        plugin<CompilerDescriptorAnalysisPlugin>().klibService providing { IdeKLibService() }
+    }
+
+    internal val ideApplicationHack by extending {
+        plugin<CompilerDescriptorAnalysisPlugin>().mockApplicationHack providing { IdeMockApplicationHack() }
+    }
+
+    internal val ideAnalysisContextCreator by extending {
+        plugin<CompilerDescriptorAnalysisPlugin>().analysisContextCreator providing { IdeAnalysisContextCreator() }
+    }
+
+    @OptIn(DokkaPluginApiPreview::class)
+    override fun pluginApiPreviewAcknowledgement(): PluginApiPreviewAcknowledgement = PluginApiPreviewAcknowledgement
+}
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeDescriptorFinder.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeDescriptorFinder.kt
new file mode 100644
index 00000000..7a1e04e4
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeDescriptorFinder.kt
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.DescriptorFinder
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToParameterDescriptorIfAny
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+
+internal class IdeDescriptorFinder : DescriptorFinder {
+    override fun KtDeclaration.findDescriptor(): DeclarationDescriptor? {
+        return if (this is KtParameter) this.resolveToParameterDescriptorIfAny(BodyResolveMode.FULL) else this.resolveToDescriptorIfAny(
+            BodyResolveMode.FULL
+        )
+    }
+
+}
+
+
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeKLibService.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeKLibService.kt
new file mode 100644
index 00000000..e1c0eb31
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeKLibService.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.KLibService
+import org.jetbrains.kotlin.library.metadata.KlibMetadataModuleDescriptorFactory
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
+import org.jetbrains.kotlin.idea.klib.CachingIdeKlibMetadataLoader
+import org.jetbrains.kotlin.idea.klib.compatibilityInfo
+import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
+import org.jetbrains.kotlin.storage.StorageManager
+
+internal class IdeKLibService : KLibService {
+    override fun KotlinLibrary.createPackageFragmentProvider(
+        storageManager: StorageManager,
+        metadataModuleDescriptorFactory: KlibMetadataModuleDescriptorFactory,
+        languageVersionSettings: LanguageVersionSettings,
+        moduleDescriptor: ModuleDescriptor,
+        lookupTracker: LookupTracker,
+    ): PackageFragmentProvider? {
+        return this.createKlibPackageFragmentProvider(
+            storageManager, metadataModuleDescriptorFactory, languageVersionSettings, moduleDescriptor, lookupTracker
+        )
+    }
+
+    override fun isAnalysisCompatible(kotlinLibrary: KotlinLibrary): Boolean {
+        return kotlinLibrary.compatibilityInfo.isCompatible
+    }
+}
+
+internal fun KotlinLibrary.createKlibPackageFragmentProvider(
+    storageManager: StorageManager,
+    metadataModuleDescriptorFactory: KlibMetadataModuleDescriptorFactory,
+    languageVersionSettings: LanguageVersionSettings,
+    moduleDescriptor: ModuleDescriptor,
+    lookupTracker: LookupTracker
+): PackageFragmentProvider? {
+    if (!compatibilityInfo.isCompatible) return null
+
+    val packageFragmentNames = CachingIdeKlibMetadataLoader.loadModuleHeader(this).packageFragmentNameList
+
+    return metadataModuleDescriptorFactory.createPackageFragmentProvider(
+        library = this,
+        packageAccessHandler = CachingIdeKlibMetadataLoader,
+        packageFragmentNames = packageFragmentNames,
+        storageManager = storageManager,
+        moduleDescriptor = moduleDescriptor,
+        configuration = CompilerDeserializationConfiguration(languageVersionSettings),
+        compositePackageFragmentAddend = null,
+        lookupTracker = lookupTracker
+    )
+}
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeMockApplicationHack.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeMockApplicationHack.kt
new file mode 100644
index 00000000..2bc83504
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdeMockApplicationHack.kt
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import com.intellij.mock.MockApplication
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.MockApplicationHack
+import org.jetbrains.kotlin.idea.klib.KlibLoadingMetadataCache
+
+internal class IdeMockApplicationHack : MockApplicationHack {
+    override fun hack(mockApplication: MockApplication) {
+        if (mockApplication.getService(KlibLoadingMetadataCache::class.java) == null)
+            mockApplication.registerService(KlibLoadingMetadataCache::class.java, KlibLoadingMetadataCache())
+    }
+}
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdePluginKDocFinder.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdePluginKDocFinder.kt
new file mode 100644
index 00000000..13119602
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/IdePluginKDocFinder.kt
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.CompilerDescriptorAnalysisPlugin
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.KDocFinder
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.querySingle
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithSource
+import org.jetbrains.kotlin.idea.kdoc.findKDoc
+import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
+import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+
+internal class IdePluginKDocFinder(
+    private val context: DokkaContext
+) : KDocFinder {
+
+    override fun KtElement.findKDoc(): KDocTag? {
+        return this.findKDoc { DescriptorToSourceUtils.descriptorToDeclaration(it) }?.contentTag
+    }
+
+    override fun DeclarationDescriptor.find(descriptorToPsi: (DeclarationDescriptorWithSource) -> PsiElement?): KDocTag? {
+        return this.findKDoc(descriptorToPsi)?.contentTag
+    }
+
+    override fun resolveKDocLink(
+        fromDescriptor: DeclarationDescriptor,
+        qualifiedName: String,
+        sourceSet: DokkaConfiguration.DokkaSourceSet,
+        emptyBindingContext: Boolean
+    ): Collection<DeclarationDescriptor> {
+        val facadeAnalysisContext = context
+            .plugin<CompilerDescriptorAnalysisPlugin>()
+            .querySingle { kotlinAnalysis }[sourceSet] as ResolutionFacadeAnalysisContext
+
+        return org.jetbrains.kotlin.idea.kdoc.resolveKDocLink(
+            context = if (emptyBindingContext) BindingContext.EMPTY else facadeAnalysisContext.resolveSession.bindingContext,
+            resolutionFacade = facadeAnalysisContext.facade,
+            fromDescriptor = fromDescriptor,
+            fromSubjectOfTag = null,
+            qualifiedName = qualifiedName.split('.'),
+            contextElement = fromDescriptor.findPsi()
+        )
+    }
+}
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/ResolutionFacadeAnalysisContext.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/ResolutionFacadeAnalysisContext.kt
new file mode 100644
index 00000000..d70aeb99
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/descriptors/ide/ResolutionFacadeAnalysisContext.kt
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.analysis.kotlin.descriptors.ide
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.configuration.AnalysisContext
+import org.jetbrains.dokka.analysis.kotlin.descriptors.compiler.configuration.AnalysisEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+
+internal class ResolutionFacadeAnalysisContext(
+    val facade: DokkaResolutionFacade,
+
+    private val kotlinEnvironment: KotlinCoreEnvironment,
+    private val analysisEnvironment: AnalysisEnvironment
+) : AnalysisContext {
+    private var isClosed: Boolean = false
+
+    override val environment: KotlinCoreEnvironment
+        get() = kotlinEnvironment.takeUnless { isClosed }
+            ?: throw IllegalStateException("AnalysisEnvironment is already closed")
+
+    override val resolveSession: ResolveSession = facade.resolveSession
+    override val moduleDescriptor: ModuleDescriptor = facade.moduleDescriptor
+    override val project: Project = facade.project
+
+    override fun close() {
+        isClosed = true
+        analysisEnvironment.dispose()
+    }
+}
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/caches/resolve/KotlinCacheService.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/caches/resolve/KotlinCacheService.kt
new file mode 100644
index 00000000..0f1b3ccf
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/caches/resolve/KotlinCacheService.kt
@@ -0,0 +1,45 @@
+// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+
+package org.jetbrains.kotlin.caches.resolve
+
+import com.intellij.openapi.components.ComponentManager
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.resolve.diagnostics.KotlinSuppressCache
+
+internal interface KotlinCacheService {
+    companion object {
+        inline fun <reified T : Any> ComponentManager.service(): T {
+            val serviceClass = T::class.java
+            return getService(serviceClass)
+                ?: error("Cannot find service ${serviceClass.name} in $this (classloader=${serviceClass.classLoader}")
+        }
+
+        fun getInstance(project: Project): KotlinCacheService = project.service()
+    }
+
+    /**
+     * Provides resolution facade for [elements], guaranteeing that the resolution will be seen from the [platform]-perspective.
+     *
+     * This allows to get resolution for common sources in MPP from the perspective of given platform (with expects substituted to actuals,
+     * declarations resolved from platform-specific artifacts, ModuleDescriptors will contain only platform dependencies, etc.)
+     *
+     * It is equivalent to usual [getResolutionFacade]-overloads if platform(s) of module(s) containing [elements] are equal to [platform]
+     *
+     * Doesn't support scripts or any other 'special' files.
+     */
+    fun getResolutionFacadeWithForcedPlatform(elements: List<KtElement>, platform: TargetPlatform): ResolutionFacade
+
+    fun getResolutionFacade(element: KtElement): ResolutionFacade
+    fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade
+    fun getResolutionFacadeByFile(file: PsiFile, platform: TargetPlatform): ResolutionFacade?
+
+    fun getSuppressionCache(): KotlinSuppressCache
+    fun getResolutionFacadeByModuleInfo(moduleInfo: ModuleInfo, platform: TargetPlatform): ResolutionFacade?
+
+    fun getResolutionFacadeByModuleInfo(moduleInfo: ModuleInfo, settings: PlatformAnalysisSettings): ResolutionFacade?
+}
\ No newline at end of file
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/caches/resolve/PlatformAnalysisSettings.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/caches/resolve/PlatformAnalysisSettings.kt
new file mode 100644
index 00000000..f828580c
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/caches/resolve/PlatformAnalysisSettings.kt
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2021 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.caches.resolve
+
+/**
+ * Regulates which sources should be analyzed together.
+ *
+ * There are exactly two descendants, which are in strong one-to-one correspondence with [ResolutionModeComponent.Mode] (meaning
+ * that after checking value of ResolutionMode, it's safe to downcast settings instance to the respective type):
+ * - [PlatformAnalysisSettingsImpl] should be used iff we're working under [Mode.SEPARATE], and will create separate
+ *   facade for each platforms, sdk, builtIns settings and other stuff.
+ *   This is the old and stable mode, which should be used by default.
+ *
+ * - [CompositeAnalysisSettings] should be used iff we're working under [Mode.COMPOSITE], and will analyze all sources
+ *   together, in one facade.
+ *   This mode is new and experimental, and works only together with TypeRefinement facilities in the compiler's frontend.
+ *   This mode is currently enabled only for HMPP projects
+ */
+internal interface PlatformAnalysisSettings
\ No newline at end of file
diff --git a/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/idea/caches/resolve/ExtendedResolutionApi.kt b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/idea/caches/resolve/ExtendedResolutionApi.kt
new file mode 100644
index 00000000..3d93093f
--- /dev/null
+++ b/dokka-subprojects/analysis-kotlin-descriptors-ide/src/main/kotlin/org/jetbrains/kotlin/idea/caches/resolve/ExtendedResolutionApi.kt
@@ -0,0 +1,78 @@
+// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+
+package org.jetbrains.kotlin.ide