Handle PsiImmediateClassType as PsiClassType to resolve bounds (#…

…2647) Fixes #2646
Kotlin · Aug 30, 2022 · a4bccbf · a4bccbf
1 parent e68eea6
commit a4bccbf
Show file tree

Hide file tree

Showing 2 changed files with 54 additions and 3 deletions.
diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
@@ -513,7 +513,7 @@ class DefaultPsiToDocumentableTranslator(
             }
 
             return when (type) {
-                is PsiClassReferenceType ->
+                is PsiClassType ->
                     type.resolve()?.let { resolved ->
                         when {
                             resolved.qualifiedName == "java.lang.Object" -> type.cacheBoundIfHasNoAnnotation { annotations -> JavaObject(annotations.annotations()) }
@@ -564,8 +564,6 @@ class DefaultPsiToDocumentableTranslator(
 
                 is PsiPrimitiveType -> if (type.name == "void") Void
                 else type.cacheBoundIfHasNoAnnotation { annotations -> PrimitiveJavaType(type.name, annotations.annotations()) }
-                is PsiImmediateClassType ->
-                    type.cacheBoundIfHasNoAnnotation { annotations -> JavaObject(annotations.annotations()) }
                 else -> throw IllegalStateException("${type.presentableText} is not supported by PSI parser")
             }
         }

diff --git a/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt b/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
@@ -4,6 +4,7 @@ import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.links.PointingToDeclaration
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.doc.Text
 import org.jetbrains.dokka.plugability.DokkaPlugin
@@ -538,4 +539,56 @@ class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
             }
         }
     }
+
+    @Test // see https://github.com/Kotlin/dokka/issues/2646
+    fun `should resolve PsiImmediateClassType as class reference`() {
+        testInline(
+            """
+            |/src/main/java/test/JavaEnum.java
+            |package test;
+            |public enum JavaEnum {
+            |    FOO, BAR
+            |}
+            |
+            |/src/main/java/test/ContainingEnumType.java
+            |package test;
+            |public class ContainingEnumType {
+            |
+            |    public JavaEnum returningEnumType() {
+            |        return null;
+            |    }
+            |
+            |    public JavaEnum[] returningEnumTypeArray() {
+            |        return null;
+            |    }
+            |
+            |    public void acceptingEnumType(JavaEnum javaEnum) {}
+            |}
+        """.trimIndent(),
+            configuration
+        ) {
+            documentablesMergingStage = { module ->
+                val expectedType = GenericTypeConstructor(
+                    dri = DRI(packageName = "test", classNames = "JavaEnum", target = PointingToDeclaration),
+                    projections = emptyList()
+                )
+                val expectedArrayType = GenericTypeConstructor(
+                    dri = DRI("kotlin", "Array", target = PointingToDeclaration),
+                    projections = listOf(expectedType)
+                )
+
+                val classWithEnumUsage = module.packages.single().classlikes.single { it.name == "ContainingEnumType" }
+
+                val returningEnum = classWithEnumUsage.functions.single { it.name == "returningEnumType" }
+                assertEquals(expectedType, returningEnum.type)
+
+                val acceptingEnum = classWithEnumUsage.functions.single { it.name == "acceptingEnumType" }
+                assertEquals(1, acceptingEnum.parameters.size)
+                assertEquals(expectedType, acceptingEnum.parameters[0].type)
+
+                val returningArray = classWithEnumUsage.functions.single { it.name == "returningEnumTypeArray" }
+                assertEquals(expectedArrayType, returningArray.type)
+            }
+        }
+    }
 }