Use KtModule

subprojects/analysis-kotlin-symbols/plugin/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/kdoc/moduledocs/ModuleAndPackageDocumentationParsingContext.kt

@@ -36,17 +36,8 @@ internal fun ModuleAndPackageDocumentationParsingContext(
     if(kotlinAnalysis == null || sourceSet == null) {
         MarkdownParser(externalDri = { null }, sourceLocation)
     } else {
-        // TODO research another ways to get AnalysisSession
         val analysisContext = kotlinAnalysis[sourceSet]
-        val someKtFile = getPsiFilesFromPaths<KtFile>(
-            analysisContext.project,
-            getSourceFilePaths(sourceSet.sourceRoots.map { it.canonicalPath })
-        ).firstOrNull()
-
-        if (someKtFile == null)
-            MarkdownParser(externalDri = { null }, sourceLocation)
-        else
-        analyze(someKtFile) {
+        analyze(analysisContext.mainModule) {
             val contextSymbol = when (fragment.classifier) {
                 Module -> getPackageSymbolIfPackageExists(FqName.topLevel(Name.identifier("")))
                 Package -> getPackageSymbolIfPackageExists(FqName(fragment.name))

subprojects/analysis-kotlin-symbols/plugin/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/kdoc/moduledocs/ModuleAndPackageDocumentationReader.kt

@@ -34,7 +34,7 @@ private class ContextModuleAndPackageDocumentationReader(
     ): SourceSetDependent<DocumentationNode> {
         return sourceSets.associateWithNotNull { sourceSet ->
             val fragments = documentationFragments[sourceSet].orEmpty().filter(predicate)
-            kotlinAnalysis[sourceSet] // to throw exception for unknown sourceSet
+            kotlinAnalysis[sourceSet] // test: to throw exception for unknown sourceSet
             val documentations = fragments.map { fragment ->
                 parseModuleAndPackageDocumentation(
                     context = ModuleAndPackageDocumentationParsingContext(context.logger, kotlinAnalysis, sourceSet),

subprojects/analysis-kotlin-symbols/plugin/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/plugin/AnalysisContext.kt

@@ -7,6 +7,7 @@ import org.jetbrains.dokka.InternalDokkaApi
 import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.kotlin.analysis.api.standalone.StandaloneAnalysisAPISession
+import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
 import java.io.Closeable
 import java.io.File
 
@@ -62,7 +63,14 @@ internal fun createAnalysisContext(
     sourceRoots: Set<File>,
     sourceSet: DokkaConfiguration.DokkaSourceSet
 ): AnalysisContext {
-    return AnalysisContextImpl(createAnalysisSession(classpath, sourceRoots, sourceSet.analysisPlatform))
+    val analysis= createAnalysisSession(
+        classpath = classpath,
+        sourceRoots = sourceRoots,
+        analysisPlatform = sourceSet.analysisPlatform,
+        languageVersion = sourceSet.languageVersion,
+        apiVersion = sourceSet.apiVersion
+    )
+    return AnalysisContextImpl(analysis.first, analysis.second,)
 }
 
 
@@ -102,9 +110,10 @@ internal open class EnvironmentKotlinAnalysis(
 
 interface AnalysisContext: Closeable {
     val project: Project
+    val mainModule: KtSourceModule
 }
 
-class AnalysisContextImpl(private val analysisSession: StandaloneAnalysisAPISession) : AnalysisContext {
+class AnalysisContextImpl(private val analysisSession: StandaloneAnalysisAPISession, override val mainModule: KtSourceModule) : AnalysisContext {
     override val project: Project
         get() = analysisSession.project
 

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

@@ -14,11 +14,13 @@ import org.jetbrains.kotlin.analysis.api.impl.base.util.LibraryUtils
 import org.jetbrains.kotlin.analysis.api.resolve.extensions.KtResolveExtensionProvider
 import org.jetbrains.kotlin.analysis.api.standalone.StandaloneAnalysisAPISession
 import org.jetbrains.kotlin.analysis.api.standalone.buildStandaloneAnalysisAPISession
+import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
 import org.jetbrains.kotlin.analysis.project.structure.builder.KtModuleBuilder
 import org.jetbrains.kotlin.analysis.project.structure.builder.buildKtLibraryModule
 import org.jetbrains.kotlin.analysis.project.structure.builder.buildKtSdkModule
 import org.jetbrains.kotlin.analysis.project.structure.builder.buildKtSourceModule
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.platform.CommonPlatforms
 import org.jetbrains.kotlin.platform.js.JsPlatforms
@@ -138,12 +140,29 @@ fun getJdkHomeFromSystemProperty(): File? {
     return File("/home/Vadim.Mishenev/.jdks/adopt-openjdk-11.0.11")
 }
 
+internal fun getLanguageVersionSettings(languageVersionString: String?, apiVersionString: String?): LanguageVersionSettingsImpl {
+    val languageVersion = LanguageVersion.fromVersionString(languageVersionString) ?: LanguageVersion.LATEST_STABLE
+    val apiVersion =
+        apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
+    return LanguageVersionSettingsImpl(
+        languageVersion = languageVersion,
+        apiVersion = apiVersion, analysisFlags = hashMapOf(
+            // special flag for Dokka
+            // force to resolve light classes (lazily by default)
+            AnalysisFlags.eagerResolveOfLightClasses to true
+        )
+    )
+}
+
 fun createAnalysisSession(
     classpath: List<File>,
     sourceRoots: Set<File>,
-    analysisPlatform: Platform
-): StandaloneAnalysisAPISession {
+    analysisPlatform: Platform,
+    languageVersion: String?,
+    apiVersion: String?
+): Pair<StandaloneAnalysisAPISession, KtSourceModule> {
 
+    var sourceModule: KtSourceModule? = null
     val analysisSession = buildStandaloneAnalysisAPISession(withPsiDeclarationFromBinaryModuleProvider = false) {
         val project = project
         val targetPlatform = analysisPlatform.toTargetPlatform()
@@ -176,32 +195,33 @@ fun createAnalysisSession(
                 )
             }
         }
+        sourceModule = buildKtSourceModule {
+             this.languageVersionSettings = getLanguageVersionSettings(languageVersion, apiVersion)
 
-        buildKtModuleProvider {
+            //val fs = StandardFileSystems.local()
+            //val psiManager = PsiManager.getInstance(project)
+            // TODO: We should handle (virtual) file changes announced via LSP with the VFS
+            /*val ktFiles = sources
+                .flatMap { Files.walk(it).toList() }
+                .mapNotNull { fs.findFileByPath(it.toString()) }
+                .mapNotNull { psiManager.findFile(it) }
+                .map { it as KtFile }*/
+            val sourcePaths = sourceRoots.map { it.absolutePath }
+            val (ktFilePath, javaFilePath) = getSourceFilePaths(sourcePaths).partition { it.endsWith(KotlinFileType.EXTENSION) }
+            val javaFiles: List<PsiFileSystemItem> = getPsiFilesFromPaths(project, javaFilePath)
+            val ktFiles: List<KtFile> = getPsiFilesFromPaths(project, getSourceFilePaths(ktFilePath))
+            addSourceRoots(ktFiles + javaFiles)
+            contentScope = TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, ktFiles)
             platform = targetPlatform
+            moduleName = "<module>"
             this.project = project
-            addModule(buildKtSourceModule {
-                //this.languageVersionSettings = it
+            addModuleDependencies(moduleName)
+        }
 
-                //val fs = StandardFileSystems.local()
-                //val psiManager = PsiManager.getInstance(project)
-                // TODO: We should handle (virtual) file changes announced via LSP with the VFS
-                /*val ktFiles = sources
-                    .flatMap { Files.walk(it).toList() }
-                    .mapNotNull { fs.findFileByPath(it.toString()) }
-                    .mapNotNull { psiManager.findFile(it) }
-                    .map { it as KtFile }*/
-                val sourcePaths = sourceRoots.map { it.absolutePath }
-                val (ktFilePath, javaFilePath) = getSourceFilePaths(sourcePaths).partition { it.endsWith(KotlinFileType.EXTENSION) }
-                val javaFiles: List<PsiFileSystemItem> = getPsiFilesFromPaths(project, javaFilePath)
-                val ktFiles: List<KtFile> = getPsiFilesFromPaths(project, getSourceFilePaths(ktFilePath))
-                addSourceRoots(ktFiles + javaFiles)
-                contentScope = TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, ktFiles)
-                platform = targetPlatform
-                moduleName = "<module>"
-                this.project = project
-                addModuleDependencies(moduleName)
-            })
+        buildKtModuleProvider {
+            platform = targetPlatform
+            this.project = project
+            addModule(sourceModule!!)
         }
     }
     // TODO remove further
@@ -210,5 +230,5 @@ fun createAnalysisSession(
         KtResolveExtensionProvider.EP_NAME.name,
         KtResolveExtensionProvider::class.java
     )
-    return analysisSession
+    return Pair(analysisSession, sourceModule ?: throw IllegalStateException())
 }

subprojects/analysis-kotlin-symbols/plugin/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/services/SamplesTransformerImpl.kt

@@ -60,13 +60,7 @@ internal abstract class SamplesTransformerImpl(val context: DokkaContext) : Page
         kotlinAnalysis: KotlinAnalysis
     ): ContentNode {
         val analysisContext = kotlinAnalysis[sourceSet]
-        // TODO research another ways to get AnalysisSession
-        val someKtFile = getPsiFilesFromPaths<KtFile>(
-            analysisContext.project,
-            getSourceFilePaths(sourceSet.samples.map { it.canonicalPath })
-        ).first()
-        // TODO Potential bug
-        val psiElement = analyze(someKtFile) {
+        val psiElement = analyze(analysisContext.mainModule) {
             val lastDotIndex = fqName.lastIndexOf('.')
 
             val functionName = if (lastDotIndex == -1) fqName else fqName.substring(lastDotIndex + 1, fqName.length)

subprojects/analysis-kotlin-symbols/plugin/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/services/SymbolExternalDocumentablesProvider.kt

@@ -25,17 +25,13 @@ internal class SymbolExternalDocumentablesProvider(val context: DokkaContext) :
 
         // TODO research another ways to get AnalysisSession
         val analysisContext = kotlinAnalysis[sourceSet]
-        val someKtFile = getPsiFilesFromPaths<KtFile>(
-            analysisContext.project,
-            getSourceFilePaths(sourceSet.sourceRoots.map { it.canonicalPath })
-        ).first()
-        analyze(someKtFile) {
-            val symbol = getClassOrObjectSymbolByClassId(classId) as? KtNamedClassOrObjectSymbol?: return null
+        return analyze(analysisContext.mainModule) {
+            val symbol = getClassOrObjectSymbolByClassId(classId) as? KtNamedClassOrObjectSymbol?: return@analyze null
             val translator = DokkaSymbolVisitor(sourceSet, sourceSet.displayName, analysisContext, logger = context.logger)
 
             val parentDRI = symbol.getContainingSymbol()?.let { getDRIFromSymbol(it) } ?: /* top level */ DRI(dri.packageName)
             with(translator) {
-                return visitNamedClassOrObjectSymbol(symbol, parentDRI)
+                return@analyze visitNamedClassOrObjectSymbol(symbol, parentDRI)
             }
         }
     }

subprojects/analysis-kotlin-symbols/plugin/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/translators/DefaultSymbolToDocumentableTranslator.kt

@@ -142,28 +142,27 @@ internal class DokkaSymbolVisitor(
             getSourceFilePaths(sourceSet.sourceRoots.map { it.canonicalPath })
         )
         val processedPackages: MutableSet<FqName> = mutableSetOf()
-        val packageSymbols: List<DPackage> = ktFiles
-            .mapNotNull {
-                analyze(it) {
+        return analyze(analysisContext.mainModule) {
+            val packageSymbols: List<DPackage> = ktFiles
+                .mapNotNull {
                     if (processedPackages.contains(it.packageFqName))
-                        return@analyze null
+                        return@mapNotNull null
                     processedPackages.add(it.packageFqName)
                     getPackageSymbolIfPackageExists(it.packageFqName)?.let { it1 ->
                         visitPackageSymbol(
                             it1
                         )
                     }
                 }
-            }
-
-        return DModule(
-            name = moduleName,
-            packages = packageSymbols,
-            documentation = emptyMap(),
-            expectPresentInSet = null,
-            sourceSets = setOf(sourceSet)
-        )
-
+
+            DModule(
+                name = moduleName,
+                packages = packageSymbols,
+                documentation = emptyMap(),
+                expectPresentInSet = null,
+                sourceSets = setOf(sourceSet)
+            )
+        }
     }
 
     private fun KtAnalysisSession.visitPackageSymbol(packageSymbol: KtPackageSymbol): DPackage {