From 8f1f344d99e2b21511dc3f4bb198d7e8729acf22 Mon Sep 17 00:00:00 2001
From: IgnatBeresnev <ignat.beresnev@jetbrains.com>
Date: Mon, 29 Aug 2022 21:27:59 +0200
Subject: [PATCH] Handle `PsiImmediateClassType` as `PsiClassType` to resolve
 bounds

Fixes #2646
---
 .../psi/DefaultPsiToDocumentableTranslator.kt |  4 +-
 .../DefaultPsiToDocumentableTranslatorTest.kt | 53 +++++++++++++++++++
 2 files changed, 54 insertions(+), 3 deletions(-)

diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
index 1fbe06f7bc..585244796a 100644
--- 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
index f5c96f4acb..5f42bd9abe 100644
--- 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)
+            }
+        }
+    }
 }