Refacotr KaJ transformer. Change wrapping TagWrapper for getters and …

…setters.
Kotlin · Feb 22, 2022 · 19a1bb7 · 19a1bb7
1 parent 9a1c15d
commit 19a1bb7
Show file tree

Hide file tree

Showing 6 changed files with 69 additions and 40 deletions.
diff --git a/...base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/...base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -647,13 +647,24 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val generics = async { descriptor.typeParameters.parallelMap { it.toVariantTypeParameter() } }
 
+            fun SourceSetDependent<DocumentationNode>.translateParamToDescription(): SourceSetDependent<DocumentationNode> {
+                return this.mapValues { (_, value) ->
+                    value.copy(children = value.children.map {
+                        when (it) {
+                            is Property -> Description(it.root)
+                            else -> it
+                        }
+                    })
+                }
+            }
+
             DFunction(
                 dri,
                 name,
                 isConstructor = false,
                 parameters = parameters,
                 visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
-                documentation = descriptor.resolveDescriptorData(),
+                documentation = descriptor.resolveDescriptorData().translateParamToDescription(),
                 type = descriptor.returnType!!.toBound(),
                 generics = generics.await(),
                 modifier = descriptor.modifier().toSourceSetDependent(),

diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
@@ -251,6 +251,7 @@ class DefaultPsiToDocumentableTranslator(
 
                 val overridden = regularFunctions.flatMap { it.findSuperMethods().toList() }
                 val documentation = javadocParser.parseDocumentation(this).toSourceSetDependent()
+                val x = superAccessors
                 val allFunctions = async {
                     regularFunctions.parallelMapNotNull {
                         if (!it.isConstructor) parseFunction(
@@ -470,6 +471,15 @@ class DefaultPsiToDocumentableTranslator(
                 Annotations.Annotation(DRI("kotlin.jvm", "JvmStatic"), emptyMap())
         }
 
+        /**
+         * Workaround for getting JvmField Kotlin annotation in PSIs
+         */
+        private fun Collection<PsiAnnotation>.getJvmFieldAnnotation() = filter {
+            it.qualifiedName == "kotlin.jvm.JvmField"
+        }.map {
+            Annotations.Annotation(DRI("kotlin.jvm", "JvmField"), emptyMap())
+        }.distinct()
+
         private fun <T : AnnotationTarget> PsiTypeParameter.annotations(): PropertyContainer<T> = this.annotations.toList().toListOfAnnotations().annotations()
         private fun <T : AnnotationTarget> PsiType.annotations(): PropertyContainer<T> = this.annotations.toList().toListOfAnnotations().annotations()
 
@@ -491,7 +501,7 @@ class DefaultPsiToDocumentableTranslator(
                     type.resolve()?.let { resolved ->
                         when {
                             resolved.qualifiedName == "java.lang.Object" -> JavaObject(type.annotations())
-                            resolved is PsiTypeParameter -> getProjection(resolved)
+                            resolved is PsiTypeParameter -> getProjection(resolved).copy(extra = type.annotations())
                             Regex("kotlin\\.jvm\\.functions\\.Function.*").matches(resolved.qualifiedName ?: "") ||
                                     Regex("java\\.util\\.function\\.Function.*").matches(
                                         resolved.qualifiedName ?: ""
@@ -628,9 +638,10 @@ class DefaultPsiToDocumentableTranslator(
                     PropertyContainer.withAll(
                         InheritedMember(inheritedFrom.toSourceSetDependent()),
                         it.toSourceSetDependent().toAdditionalModifiers(),
-                        (psi.annotations.toList()
-                            .toListOfAnnotations() + it.toListOfAnnotations()).toSourceSetDependent()
-                            .toAnnotations()
+                        (psi.annotations.toList().toListOfAnnotations() +
+                                it.toListOfAnnotations() +
+                                psi.annotations.toList().getJvmFieldAnnotation()
+                        ).toSourceSetDependent().toAnnotations()
                     )
                 }
             )

diff --git a/plugins/base/src/test/kotlin/superFields/PsiSuperFieldsTest.kt b/plugins/base/src/test/kotlin/superFields/PsiSuperFieldsTest.kt
@@ -2,6 +2,7 @@ package superFields
 
 import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.Annotations
 import org.jetbrains.dokka.model.InheritedMember
 import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Assertions.assertNotNull
@@ -124,6 +125,10 @@ class PsiSuperFieldsTest : BaseAbstractTest() {
                     assertNotNull(this)
                     assertNull(this.getter)
                     assertNull(this.setter)
+                    assertNotNull(this.extra[Annotations]?.directAnnotations?.values?.single()?.find {
+                        it.dri.packageName == "kotlin.jvm" &&
+                                it.dri.classNames == "JvmField"
+                    })
                     this.extra[InheritedMember]?.inheritedFrom?.values?.single()?.run {
                         assertEquals(
                             DRI(packageName = "test", classNames = "A"),

diff --git a/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt b/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt
@@ -275,7 +275,7 @@ internal fun DClass.functionsInJava(): List<DFunction> =
         .flatMap { property -> listOfNotNull(property.getter, property.setter) }
         .plus(functions)
         .filterNot { it.hasJvmSynthetic() }
-        .flatMap { it.asJava(dri.classNames ?: name) }
+        .flatMap { it.asJava(it.dri.classNames ?: it.name) }
 
 private fun DTypeParameter.asJava(): DTypeParameter = copy(
     variantTypeParameter = variantTypeParameter.withDri(dri.possiblyAsJava()),

diff --git a/plugins/kotlin-as-java/src/main/kotlin/transformToJava.kt b/plugins/kotlin-as-java/src/main/kotlin/transformToJava.kt
@@ -7,23 +7,24 @@ import org.jetbrains.dokka.model.DFunction
 import org.jetbrains.dokka.model.DPackage
 import org.jetbrains.dokka.model.DProperty
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.utilities.DokkaLogger
 
 private val JVM_NAME_DOCUMENTABLE_TRANSFORMER by lazy {
     JvmNameDocumentableTransformer()
 }
 
-fun DPackage.transformToJava(context: DokkaContext): DPackage {
-    return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this.asJava(), context)
+fun DPackage.transformToJava(logger: DokkaLogger): DPackage {
+    return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this.asJava(), logger)
 }
 
-fun DClasslike.transformToJava(context: DokkaContext): DClasslike {
-    return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this.asJava(), context)
+fun DClasslike.transformToJava(logger: DokkaLogger): DClasslike {
+    return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this.asJava(), logger)
 }
 
-fun DFunction.transformToJava(context: DokkaContext, containingClassName: String, isTopLevel: Boolean = false): List<DFunction> {
-    return this.asJava(containingClassName, isTopLevel).map { JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(it, context) }
+fun DFunction.transformToJava(logger: DokkaLogger, containingClassName: String, isTopLevel: Boolean = false): List<DFunction> {
+    return this.asJava(containingClassName, isTopLevel).map { JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(it, logger) }
 }
 
-fun DProperty.transformToJava(context: DokkaContext, isTopLevel: Boolean = false, relocateToClass: String? = null): DProperty {
-    return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this.asJava(isTopLevel, relocateToClass), context)
+fun DProperty.transformToJava(logger: DokkaLogger, isTopLevel: Boolean = false, relocateToClass: String? = null): DProperty {
+    return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this.asJava(isTopLevel, relocateToClass), logger)
 }
diff --git a/plugins/kotlin-as-java/src/main/kotlin/transformers/JvmNameDocumentableTransformer.kt b/plugins/kotlin-as-java/src/main/kotlin/transformers/JvmNameDocumentableTransformer.kt
@@ -4,21 +4,22 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer
+import org.jetbrains.dokka.utilities.DokkaLogger
 
 class JvmNameDocumentableTransformer : DocumentableTransformer {
     private val jvmNameProvider = JvmNameProvider()
 
     override fun invoke(original: DModule, context: DokkaContext): DModule {
-        return original.copy(packages = original.packages.map { transform(it, context) })
+        return original.copy(packages = original.packages.map { transform(it, context.logger) })
     }
 
-    internal fun <T : Documentable> transform(documentable: T, context: DokkaContext): T =
+    internal fun <T : Documentable> transform(documentable: T, logger: DokkaLogger): T =
         with(documentable) {
             when (this) {
                 is DPackage -> copy(
-                    functions = functions.map { transform(it, context) },
-                    properties = properties.map { transform(it, context) },
-                    classlikes = classlikes.map { transform(it, context) },
+                    functions = functions.map { transform(it, logger) },
+                    properties = properties.map { transform(it, logger) },
+                    classlikes = classlikes.map { transform(it, logger) },
                 )
                 is DFunction -> {
                     val name = jvmNameProvider.nameFor(this)
@@ -29,14 +30,14 @@ class JvmNameDocumentableTransformer : DocumentableTransformer {
                     )
                 }
                 is DProperty -> transformGetterAndSetter(this)
-                is DClasslike -> transformClassLike(this, context)
+                is DClasslike -> transformClassLike(this, logger)
                 is DEnumEntry -> copy(
-                    functions = functions.map { transform(it, context) },
-                    properties = properties.map { transform(it, context) },
-                    classlikes = classlikes.map { transform(it, context) },
+                    functions = functions.map { transform(it, logger) },
+                    properties = properties.map { transform(it, logger) },
+                    classlikes = classlikes.map { transform(it, logger) },
                 )
                 else -> {
-                    context.logger.warn("Failed to translate a JvmName for ${this.javaClass.canonicalName}")
+                    logger.warn("Failed to translate a JvmName for ${this.javaClass.canonicalName}")
                     this
                 }
             }
@@ -53,33 +54,33 @@ class JvmNameDocumentableTransformer : DocumentableTransformer {
         return extraWithoutAnnotations.addAll(listOfNotNull(annotationsWithoutJvmName))
     }
 
-    private fun transformClassLike(documentable: DClasslike, context: DokkaContext): DClasslike =
+    private fun transformClassLike(documentable: DClasslike, logger: DokkaLogger): DClasslike =
         with(documentable) {
             when (this) {
                 is DClass -> copy(
-                    functions = functions.map { transform(it, context) },
-                    properties = properties.map { transform(it, context) },
-                    classlikes = classlikes.map { transform(it, context) },
+                    functions = functions.map { transform(it, logger) },
+                    properties = properties.map { transform(it, logger) },
+                    classlikes = classlikes.map { transform(it, logger) },
                 )
                 is DAnnotation -> copy(
-                    functions = functions.map { transform(it, context) },
-                    properties = properties.map { transform(it, context) },
-                    classlikes = classlikes.map { transform(it, context) },
+                    functions = functions.map { transform(it, logger) },
+                    properties = properties.map { transform(it, logger) },
+                    classlikes = classlikes.map { transform(it, logger) },
                 )
                 is DObject -> copy(
-                    functions = functions.map { transform(it, context) },
-                    properties = properties.map { transform(it, context) },
-                    classlikes = classlikes.map { transform(it, context) },
+                    functions = functions.map { transform(it, logger) },
+                    properties = properties.map { transform(it, logger) },
+                    classlikes = classlikes.map { transform(it, logger) },
                 )
                 is DEnum -> copy(
-                    functions = functions.map { transform(it, context) },
-                    properties = properties.map { transform(it, context) },
-                    classlikes = classlikes.map { transform(it, context) },
+                    functions = functions.map { transform(it, logger) },
+                    properties = properties.map { transform(it, logger) },
+                    classlikes = classlikes.map { transform(it, logger) },
                 )
                 is DInterface -> copy(
-                    functions = functions.map { transform(it, context) },
-                    properties = properties.map { transform(it, context) },
-                    classlikes = classlikes.map { transform(it, context) },
+                    functions = functions.map { transform(it, logger) },
+                    properties = properties.map { transform(it, logger) },
+                    classlikes = classlikes.map { transform(it, logger) },
                 )
             }
         }