Refactor

kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt → kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisContext.kt

@@ -11,17 +11,17 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import java.io.Closeable
 import java.io.File
 
-internal fun createEnvironmentAndFacade(
+internal fun createAnalysisContext(
     logger: DokkaLogger,
     sourceSets: List<DokkaConfiguration.DokkaSourceSet>,
     sourceSet: DokkaConfiguration.DokkaSourceSet,
     analysisConfiguration: DokkaAnalysisConfiguration
-): EnvironmentAndFacade {
+): AnalysisContext {
     val parentSourceSets = sourceSets.filter { it.sourceSetID in sourceSet.dependentSourceSets }
     val classpath = sourceSet.classpath + parentSourceSets.flatMap { it.classpath }
     val sources = sourceSet.sourceRoots + parentSourceSets.flatMap { it.sourceRoots }
 
-    return createEnvironmentAndFacade(
+    return createAnalysisContext(
         logger = logger,
         classpath = classpath,
         sourceRoots = sources,
@@ -30,25 +30,30 @@ internal fun createEnvironmentAndFacade(
     )
 }
 
-internal fun createEnvironmentAndFacade(
+internal fun createAnalysisContext(
     logger: DokkaLogger,
     classpath: List<File>,
     sourceRoots: Set<File>,
     sourceSet: DokkaConfiguration.DokkaSourceSet,
     analysisConfiguration: DokkaAnalysisConfiguration
-) = AnalysisEnvironment(DokkaMessageCollector(logger), sourceSet.analysisPlatform).run {
-    if (analysisPlatform == Platform.jvm) {
-        configureJdkClasspathRoots()
-    }
-    addClasspath(classpath)
-    addSources(sourceRoots)
+): AnalysisContext {
+    val analysisEnvironment = AnalysisEnvironment(DokkaMessageCollector(logger), sourceSet.analysisPlatform).apply {
+        if (analysisPlatform == Platform.jvm) {
+            configureJdkClasspathRoots()
+        }
+        addClasspath(classpath)
+        addSources(sourceRoots)
 
-    loadLanguageVersionSettings(sourceSet.languageVersion, sourceSet.apiVersion)
+        loadLanguageVersionSettings(sourceSet.languageVersion, sourceSet.apiVersion)
+    }
 
-    val environment = createCoreEnvironment()
+    val environment = analysisEnvironment.createCoreEnvironment()
+    val (facade, _) = analysisEnvironment.createResolutionFacade(
+        environment,
+        analysisConfiguration.ignoreCommonBuiltIns
+    )
 
-    val (facade, _) = createResolutionFacade(environment, analysisConfiguration.ignoreCommonBuiltIns)
-    EnvironmentAndFacade(environment, facade, this)
+    return AnalysisContext(environment, facade, analysisEnvironment)
 }
 
 class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
@@ -69,7 +74,7 @@ class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector
 }
 
 // It is not data class due to ill-defined equals
-class EnvironmentAndFacade(
+class AnalysisContext(
     environment: KotlinCoreEnvironment,
     facade: DokkaResolutionFacade,
     private val analysisEnvironment: AnalysisEnvironment

kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt

@@ -15,26 +15,29 @@ fun KotlinAnalysis(
     analysisConfiguration: DokkaAnalysisConfiguration = DokkaAnalysisConfiguration()
 ): KotlinAnalysis {
     val environments = sourceSets.associateWith { sourceSet ->
-        createEnvironmentAndFacade(
+        createAnalysisContext(
             logger = logger,
             sourceSets = sourceSets,
             sourceSet = sourceSet,
             analysisConfiguration = analysisConfiguration
         )
     }
-    return KotlinAnalysisImpl(environments)
+    return ProjectKotlinAnalysis(environments)
 }
 
-fun KotlinAnalysisForSamples(
+/**
+ * [projectKotlinAnalysis] needs to be closed separately
+ */
+fun SamplesKotlinAnalysis(
     sourceSets: List<DokkaSourceSet>,
     logger: DokkaLogger,
-    defaultKotlinAnalysis: KotlinAnalysis,
+    projectKotlinAnalysis: KotlinAnalysis,
     analysisConfiguration: DokkaAnalysisConfiguration = DokkaAnalysisConfiguration()
 ): KotlinAnalysis {
     val environments = sourceSets
         .filter { it.samples.isNotEmpty() }
         .associateWith { sourceSet ->
-            createEnvironmentAndFacade(
+            createAnalysisContext(
                 logger = logger,
                 classpath = sourceSet.classpath,
                 sourceRoots = sourceSet.samples,
@@ -43,7 +46,7 @@ fun KotlinAnalysisForSamples(
             )
     }
 
-    return KotlinAnalysisImpl(environments, defaultKotlinAnalysis)
+    return SamplesKotlinAnalysis(environments, projectKotlinAnalysis)
 }
 
 class DokkaAnalysisConfiguration(
@@ -59,30 +62,39 @@ class DokkaAnalysisConfiguration(
 )
 fun KotlinAnalysis(context: DokkaContext): KotlinAnalysis = KotlinAnalysis(context.configuration.sourceSets, context.logger)
 
-interface KotlinAnalysis : SourceSetDependent<EnvironmentAndFacade>, Closeable {
-    override fun get(key: DokkaSourceSet): EnvironmentAndFacade
-    operator fun get(sourceSetID: DokkaSourceSetID): EnvironmentAndFacade
+interface KotlinAnalysis : SourceSetDependent<AnalysisContext>, Closeable {
+    override fun get(key: DokkaSourceSet): AnalysisContext
+    operator fun get(sourceSetID: DokkaSourceSetID): AnalysisContext
 }
 
+internal class ProjectKotlinAnalysis(
+    environments: SourceSetDependent<AnalysisContext>
+) : KotlinAnalysisImpl(environments)
+
+internal class SamplesKotlinAnalysis(
+    sampleEnvironments: SourceSetDependent<AnalysisContext>,
+    projectKotlinAnalysis: KotlinAnalysis
+) : KotlinAnalysisImpl(sampleEnvironments, projectKotlinAnalysis)
+
 /**
  * It does not close [defaultKotlinAnalysis].
  */
-internal class KotlinAnalysisImpl(
-    private val environments: SourceSetDependent<EnvironmentAndFacade>,
+internal open class KotlinAnalysisImpl(
+    private val environments: SourceSetDependent<AnalysisContext>,
     private val defaultKotlinAnalysis: KotlinAnalysis? = null
-) : KotlinAnalysis, SourceSetDependent<EnvironmentAndFacade> by environments {
+) : KotlinAnalysis, SourceSetDependent<AnalysisContext> by environments {
 
-    override fun get(key: DokkaSourceSet): EnvironmentAndFacade {
+    override fun get(key: DokkaSourceSet): AnalysisContext {
         return environments[key] ?: defaultKotlinAnalysis?.get(key)
         ?: throw IllegalStateException("Missing EnvironmentAndFacade for sourceSet $key")
     }
 
-    override fun get(sourceSetID: DokkaSourceSetID): EnvironmentAndFacade {
+    override fun get(sourceSetID: DokkaSourceSetID): AnalysisContext {
         return environments.entries.firstOrNull { (sourceSet, _) -> sourceSet.sourceSetID == sourceSetID }?.value
             ?: defaultKotlinAnalysis?.get(sourceSetID)
             ?: throw IllegalStateException("Missing EnvironmentAndFacade for sourceSetID $sourceSetID")
     }
     override fun close() {
-        environments.values.forEach(EnvironmentAndFacade::close)
+        environments.values.forEach(AnalysisContext::close)
     }
 }

plugins/base/api/base.api

@@ -13,7 +13,6 @@ public final class org/jetbrains/dokka/base/DokkaBase : org/jetbrains/dokka/plug
 	public final fun getDefaultTabSortingStrategy ()Lorg/jetbrains/dokka/plugability/Extension;
 	public final fun getDeprecatedDocumentableFilter ()Lorg/jetbrains/dokka/plugability/Extension;
 	public final fun getDescriptorToDocumentableTranslator ()Lorg/jetbrains/dokka/plugability/Extension;
-	public final fun getDisposeKotlinAnalysisPostAction ()Lorg/jetbrains/dokka/plugability/Extension;
 	public final fun getDocTagToContentConverter ()Lorg/jetbrains/dokka/plugability/Extension;
 	public final fun getDocumentableMerger ()Lorg/jetbrains/dokka/plugability/Extension;
 	public final fun getDocumentableToPageTranslator ()Lorg/jetbrains/dokka/plugability/Extension;

plugins/base/src/main/kotlin/DokkaBase.kt

@@ -283,7 +283,7 @@ class DokkaBase : DokkaPlugin() {
         externalClasslikesTranslator providing ::DefaultDescriptorToDocumentableTranslator
     }
 
-    val disposeKotlinAnalysisPostAction by extending {
+    internal val disposeKotlinAnalysisPostAction by extending {
         CoreExtensions.postActions with PostAction { this@DokkaBase.querySingle { kotlinAnalysis }.close() }
     }
 

plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt

@@ -34,9 +34,11 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
          * Currently, all `ThreadLocal`s are in a compiler/IDE codebase.
          */
         runBlocking(Dispatchers.Default) {
-            val analysis = KotlinAnalysisForSamples(sourceSets = context.configuration.sourceSets,
+            val analysis = SamplesKotlinAnalysis(
+                sourceSets = context.configuration.sourceSets,
                 logger = context.logger,
-                defaultKotlinAnalysis = context.plugin<DokkaBase>().querySingle { kotlinAnalysis })
+                projectKotlinAnalysis = context.plugin<DokkaBase>().querySingle { kotlinAnalysis }
+            )
             analysis.use {
                 input.transformContentPagesTree { page ->
                     val samples = (page as? WithDocumentables)?.documentables?.flatMap {
@@ -59,7 +61,7 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         contentPage: ContentPage,
         sourceSet: DokkaSourceSet,
         fqName: String,
-        analysis: Map<DokkaSourceSet, EnvironmentAndFacade>
+        analysis: Map<DokkaSourceSet, AnalysisContext>
     ): ContentNode {
         val facade = analysis[sourceSet]?.facade
             ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${sourceSet.sourceSetID}") }