Bug resolving in ultralightmethod

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

@@ -478,7 +478,7 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
                 projectContext.withModule(descriptor),
                 modulesContent(moduleInfo),
                 this,
-                LanguageVersionSettingsImpl.DEFAULT,
+                configuration.languageVersionSettings,
                 CliSealedClassInheritorsProvider,
             )
 
@@ -490,7 +490,11 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         val languageVersion = LanguageVersion.fromVersionString(languageVersionString) ?: LanguageVersion.LATEST_STABLE
         val apiVersion =
             apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
-        configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
+        configuration.languageVersionSettings = LanguageVersionSettingsImpl(
+            languageVersion = languageVersion,
+            apiVersion = apiVersion,
+            analysisFlags = hashMapOf(org.jetbrains.kotlin.config.AnalysisFlags.eagerResolveOfLightClasses to true)
+        )
     }
 
     /**

plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt

@@ -1,13 +1,17 @@
 package translators
 
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
+import org.jetbrains.dokka.model.TypeConstructor
 import org.jetbrains.dokka.model.doc.Text
 import org.jetbrains.dokka.model.firstMemberOfType
-import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Annotations
+import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
+import utils.assertNotNull
 
 class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
     val configuration = dokkaConfiguration {
@@ -193,4 +197,64 @@ class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
             }
         }
     }
+
+    class OnlyPsiPlugin : DokkaPlugin() {
+        private val dokkaBase by lazy { plugin<DokkaBase>() }
+
+        @Suppress("unused")
+        val psiOverrideDescriptorTranslator by extending {
+            (dokkaBase.psiToDocumentableTranslator
+                    override dokkaBase.descriptorToDocumentableTranslator)
+        }
+    }
+
+    @Test
+    fun `psi bug`() {
+        val configurationWithNoJVM = dokkaConfiguration {
+            sourceSets {
+                sourceSet {
+                    sourceRoots = listOf("src/main/java")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/java/example/Test.kt
+            |package example
+            |
+            |open class KotlinSubClass {
+            |    fun kotlinSubclassFunction(bar: String): String {
+            |       return "KotlinSubClass"
+            |    }
+            |}
+            |
+            |/src/main/java/example/JavaLeafClass.java
+            |package example;
+            |
+            |public class JavaLeafClass extends KotlinSubClass {
+            |    public String javaLeafClassFunction(String baz) {
+            |        return "JavaLeafClass";
+            |    }
+            |}
+        """.trimMargin(),
+            configurationWithNoJVM,
+            pluginOverrides = listOf(OnlyPsiPlugin()) // suppress a descriptor translator because of psi and descriptor translators work in parallel
+        ) {
+            documentablesMergingStage = { module ->
+                val kotlinSubclassFunction =
+                    module.packages.single().classlikes.find { it.name == "JavaLeafClass" }?.functions?.find { it.name == "kotlinSubclassFunction" }
+                        .assertNotNull("kotlinSubclassFunction ")
+
+                assertEquals(
+                    "String",
+                    (kotlinSubclassFunction.type as? TypeConstructor)?.dri?.classNames
+                )
+                assertEquals(
+                    "String",
+                    (kotlinSubclassFunction.parameters.firstOrNull()?.type as? TypeConstructor)?.dri?.classNames
+                )
+            }
+        }
+    }
 }