Decompose Kotlin/Java analysis (#3034)

* Extract analysis into separate modules

6 files changed, 0 insertions, 1518 deletions

diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
deleted file mode 100644
index ce4776e7..00000000
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ /dev/null
@@ -1,1250 +0,0 @@
-package org.jetbrains.dokka.base.translators.descriptors
-
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiNamedElement
-import com.intellij.psi.util.PsiLiteralUtil.*
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.runBlocking
-import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
-import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
-import org.jetbrains.dokka.analysis.DokkaResolutionFacade
-import org.jetbrains.dokka.analysis.KotlinAnalysis
-import org.jetbrains.dokka.analysis.from
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.base.parsers.MarkdownParser
-import org.jetbrains.dokka.base.translators.psi.parsers.JavadocParser
-import org.jetbrains.dokka.base.translators.typeConstructorsBeingExceptions
-import org.jetbrains.dokka.base.translators.unquotedValue
-import org.jetbrains.dokka.links.*
-import org.jetbrains.dokka.links.Callable
-import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.model.AnnotationTarget
-import org.jetbrains.dokka.model.Nullable
-import org.jetbrains.dokka.model.Visibility
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.querySingle
-import org.jetbrains.dokka.transformers.sources.AsyncSourceToDocumentableTranslator
-import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.dokka.utilities.parallelMap
-import org.jetbrains.dokka.utilities.parallelMapNotNull
-import org.jetbrains.kotlin.KtNodeTypes
-import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
-import org.jetbrains.kotlin.builtins.isBuiltinExtensionFunctionalType
-import org.jetbrains.kotlin.builtins.isExtensionFunctionType
-import org.jetbrains.kotlin.builtins.isSuspendFunctionTypeOrSubtype
-import org.jetbrains.kotlin.codegen.isJvmStaticInObjectOrClassOrInterface
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.annotations.Annotated
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.descriptors.java.JavaVisibilities
-import org.jetbrains.kotlin.idea.kdoc.findKDoc
-import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
-import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
-import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
-import org.jetbrains.kotlin.load.kotlin.toSourceElement
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.calls.components.isVararg
-import org.jetbrains.kotlin.resolve.calls.util.getValueArgumentsInParentheses
-import org.jetbrains.kotlin.resolve.constants.ConstantValue
-import org.jetbrains.kotlin.resolve.constants.KClassValue.Value.LocalClass
-import org.jetbrains.kotlin.resolve.constants.KClassValue.Value.NormalClass
-import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull
-import org.jetbrains.kotlin.resolve.descriptorUtil.parents
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.resolve.scopes.StaticScopeForKotlinEnum
-import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
-import org.jetbrains.kotlin.resolve.source.PsiSourceElement
-import org.jetbrains.kotlin.resolve.source.PsiSourceFile
-import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.typeUtil.immediateSupertypes
-import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-import java.nio.file.Paths
-import org.jetbrains.kotlin.resolve.constants.AnnotationValue as ConstantsAnnotationValue
-import org.jetbrains.kotlin.resolve.constants.ArrayValue as ConstantsArrayValue
-import org.jetbrains.kotlin.resolve.constants.BooleanValue as ConstantsBooleanValue
-import org.jetbrains.kotlin.resolve.constants.DoubleValue as ConstantsDoubleValue
-import org.jetbrains.kotlin.resolve.constants.EnumValue as ConstantsEnumValue
-import org.jetbrains.kotlin.resolve.constants.FloatValue as ConstantsFloatValue
-import org.jetbrains.kotlin.resolve.constants.IntValue as ConstantsIntValue
-import org.jetbrains.kotlin.resolve.constants.KClassValue as ConstantsKtClassValue
-import org.jetbrains.kotlin.resolve.constants.LongValue as ConstantsLongValue
-import org.jetbrains.kotlin.resolve.constants.NullValue as ConstantsNullValue
-import org.jetbrains.kotlin.resolve.constants.UIntValue as ConstantsUIntValue
-import org.jetbrains.kotlin.resolve.constants.ULongValue as ConstantsULongValue
-
-class DefaultDescriptorToDocumentableTranslator(
-    private val context: DokkaContext
-) : AsyncSourceToDocumentableTranslator, ExternalClasslikesTranslator {
-
-    private val kotlinAnalysis: KotlinAnalysis = context.plugin<DokkaBase>().querySingle { kotlinAnalysis }
-
-    override suspend fun invokeSuspending(sourceSet: DokkaSourceSet, context: DokkaContext): DModule {
-        val (environment, facade) = kotlinAnalysis[sourceSet]
-        val packageFragments = environment.getSourceFiles().asSequence()
-            .map { it.packageFqName }
-            .distinct()
-            .mapNotNull { facade.resolveSession.getPackageFragment(it) }
-            .toList()
-
-        return DokkaDescriptorVisitor(sourceSet, kotlinAnalysis[sourceSet].facade, context.logger).run {
-            packageFragments.mapNotNull { it.safeAs<PackageFragmentDescriptor>() }.parallelMap {
-                visitPackageFragmentDescriptor(
-                    it
-                )
-            }
-        }.let {
-            DModule(
-                name = context.configuration.moduleName,
-                packages = it,
-                documentation = emptyMap(),
-                expectPresentInSet = null,
-                sourceSets = setOf(sourceSet)
-            )
-        }
-    }
-
-    override fun translateClassDescriptor(descriptor: ClassDescriptor, sourceSet: DokkaSourceSet): DClasslike {
-        val driInfo = DRI.from(descriptor.parents.first()).withEmptyInfo()
-
-        return runBlocking(Dispatchers.Default) {
-            DokkaDescriptorVisitor(sourceSet, kotlinAnalysis[sourceSet].facade, context.logger)
-                .visitClassDescriptor(descriptor, driInfo)
-        }
-    }
-}
-
-data class DRIWithPlatformInfo(
-    val dri: DRI,
-    val actual: SourceSetDependent<DocumentableSource>
-)
-
-fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, emptyMap())
-
-private class DokkaDescriptorVisitor(
-    private val sourceSet: DokkaSourceSet,
-    private val resolutionFacade: DokkaResolutionFacade,
-    private val logger: DokkaLogger
-) {
-    private val javadocParser = JavadocParser(logger, resolutionFacade)
-    private val syntheticDocProvider = SyntheticDescriptorDocumentationProvider(resolutionFacade)
-
-    private fun Collection<DeclarationDescriptor>.filterDescriptorsInSourceSet() = filter {
-        it.toSourceElement.containingFile.toString().let { path ->
-            path.isNotBlank() && sourceSet.sourceRoots.any { root ->
-                Paths.get(path).startsWith(root.toPath())
-            }
-        }
-    }
-
-    private fun <T> T.toSourceSetDependent() = if (this != null) mapOf(sourceSet to this) else emptyMap()
-
-    suspend fun visitPackageFragmentDescriptor(descriptor: PackageFragmentDescriptor): DPackage {
-        val name = descriptor.fqName.asString().takeUnless { it.isBlank() } ?: ""
-        val driWithPlatform = DRI(packageName = name).withEmptyInfo()
-        val scope = descriptor.getMemberScope()
-        return coroutineScope {
-            val descriptorsWithKind = scope.getDescriptorsWithKind(true)
-
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
-            val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-            val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases() }
-
-            DPackage(
-                dri = driWithPlatform.dri,
-                functions = functions.await(),
-                properties = properties.await(),
-                classlikes = classlikes.await(),
-                typealiases = typealiases.await(),
-                documentation = descriptor.resolveDescriptorData(),
-                sourceSets = setOf(sourceSet)
-            )
-        }
-    }
-
-    suspend fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): DClasslike =
-        when (descriptor.kind) {
-            ClassKind.ENUM_CLASS -> enumDescriptor(descriptor, parent)
-            ClassKind.OBJECT -> objectDescriptor(descriptor, parent)
-            ClassKind.INTERFACE -> interfaceDescriptor(descriptor, parent)
-            ClassKind.ANNOTATION_CLASS -> annotationDescriptor(descriptor, parent)
-            else -> classDescriptor(descriptor, parent)
-        }
-
-    private suspend fun interfaceDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): DInterface {
-        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
-        val scope = descriptor.unsubstitutedMemberScope
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-        val info = descriptor.resolveClassDescriptionData()
-
-        return coroutineScope {
-            val descriptorsWithKind = scope.getDescriptorsWithKind()
-
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
-            val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-            val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
-
-            DInterface(
-                dri = driWithPlatform.dri,
-                name = descriptor.name.asString(),
-                functions = functions.await(),
-                properties = properties.await(),
-                classlikes = classlikes.await(),
-                sources = descriptor.createSources(),
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
-                supertypes = info.supertypes.toSourceSetDependent(),
-                documentation = info.docs,
-                generics = generics.await(),
-                companion = descriptor.companion(driWithPlatform),
-                sourceSets = setOf(sourceSet),
-                isExpectActual = (isExpect || isActual),
-                extra = PropertyContainer.withAll(
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    descriptor.getAnnotations().toSourceSetDependent().toAnnotations(),
-                    ImplementedInterfaces(info.ancestry.allImplementedInterfaces().toSourceSetDependent()),
-                    info.ancestry.exceptionInSupertypesOrNull()
-                )
-            )
-        }
-    }
-
-    private suspend fun objectDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): DObject {
-        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
-        val scope = descriptor.unsubstitutedMemberScope
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-        val info = descriptor.resolveClassDescriptionData()
-
-
-        return coroutineScope {
-            val descriptorsWithKind = scope.getDescriptorsWithKind()
-
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
-            val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-
-            DObject(
-                dri = driWithPlatform.dri,
-                name = descriptor.name.asString(),
-                functions = functions.await(),
-                properties = properties.await(),
-                classlikes = classlikes.await(),
-                sources = descriptor.createSources(),
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
-                supertypes = info.supertypes.toSourceSetDependent(),
-                documentation = info.docs,
-                sourceSets = setOf(sourceSet),
-                isExpectActual = (isExpect || isActual),
-                extra = PropertyContainer.withAll(
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    descriptor.getAnnotations().toSourceSetDependent().toAnnotations(),
-                    ImplementedInterfaces(info.ancestry.allImplementedInterfaces().toSourceSetDependent()),
-                    info.ancestry.exceptionInSupertypesOrNull()
-                )
-            )
-        }
-
-
-    }
-
-    private suspend fun enumDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): DEnum {
-        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-        val info = descriptor.resolveClassDescriptionData()
-
-        return coroutineScope {
-            val descriptorsWithKind = descriptor.getEnumDescriptorsWithKind()
-
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
-            val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-            val constructors =
-                async { descriptor.constructors.parallelMap { visitConstructorDescriptor(it, driWithPlatform) } }
-            val entries = async { descriptorsWithKind.enumEntries.visitEnumEntries(driWithPlatform) }
-
-            DEnum(
-                dri = driWithPlatform.dri,
-                name = descriptor.name.asString(),
-                entries = entries.await(),
-                constructors = constructors.await(),
-                functions = functions.await(),
-                properties = properties.await(),
-                classlikes = classlikes.await(),
-                sources = descriptor.createSources(),
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
-                supertypes = info.supertypes.toSourceSetDependent(),
-                documentation = info.docs,
-                companion = descriptor.companion(driWithPlatform),
-                sourceSets = setOf(sourceSet),
-                isExpectActual = (isExpect || isActual),
-                extra = PropertyContainer.withAll(
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    descriptor.getAnnotations().toSourceSetDependent().toAnnotations(),
-                    ImplementedInterfaces(info.ancestry.allImplementedInterfaces().toSourceSetDependent())
-                )
-            )
-        }
-    }
-
-    private fun ClassDescriptor.getEnumDescriptorsWithKind(): DescriptorsWithKind {
-        val descriptorsWithKind = this.unsubstitutedMemberScope.getDescriptorsWithKind()
-        val staticScopeForKotlinEnum = (this.staticScope as? StaticScopeForKotlinEnum) ?: return descriptorsWithKind
-
-        // synthetic values() and valueOf() functions are not present among average class functions
-        val enumSyntheticFunctions = staticScopeForKotlinEnum.getContributedDescriptors { true }
-            .filterIsInstance<FunctionDescriptor>()
-
-        return descriptorsWithKind.copy(functions = descriptorsWithKind.functions + enumSyntheticFunctions)
-    }
-
-    private suspend fun visitEnumEntryDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): DEnumEntry {
-        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
-        val scope = descriptor.unsubstitutedMemberScope
-        val isExpect = descriptor.isExpect
-
-        return coroutineScope {
-            val descriptorsWithKind = scope.getDescriptorsWithKind()
-
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
-            val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-
-            DEnumEntry(
-                dri = driWithPlatform.dri.withEnumEntryExtra(),
-                name = descriptor.name.asString(),
-                documentation = descriptor.resolveDescriptorData(),
-                functions = functions.await(),
-                properties = properties.await(),
-                classlikes = classlikes.await(),
-                sourceSets = setOf(sourceSet),
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                extra = PropertyContainer.withAll(
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    descriptor.getAnnotations().toSourceSetDependent().toAnnotations()
-                )
-            )
-        }
-    }
-
-    private suspend fun annotationDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): DAnnotation {
-        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
-        val scope = descriptor.unsubstitutedMemberScope
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-
-        return coroutineScope {
-            val descriptorsWithKind = scope.getDescriptorsWithKind()
-
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
-            val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-            val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
-            val constructors =
-                async { descriptor.constructors.parallelMap { visitConstructorDescriptor(it, driWithPlatform) } }
-
-            DAnnotation(
-                dri = driWithPlatform.dri,
-                name = descriptor.name.asString(),
-                documentation = descriptor.resolveDescriptorData(),
-                functions = functions.await(),
-                properties = properties.await(),
-                classlikes = classlikes.await(),
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                sourceSets = setOf(sourceSet),
-                isExpectActual = (isExpect || isActual),
-                extra = PropertyContainer.withAll(
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    descriptor.getAnnotations().toSourceSetDependent().toAnnotations()
-                ),
-                companion = descriptor.companionObjectDescriptor?.let { objectDescriptor(it, driWithPlatform) },
-                visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
-                generics = generics.await(),
-                constructors = constructors.await(),
-                sources = descriptor.createSources()
-            )
-        }
-
-
-    }
-
-    private suspend fun classDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): DClass {
-        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
-        val scope = descriptor.unsubstitutedMemberScope
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-        val info = descriptor.resolveClassDescriptionData()
-        val actual = descriptor.createSources()
-
-        return coroutineScope {
-            val descriptorsWithKind = scope.getDescriptorsWithKind()
-
-            val (regularFunctions, accessors) = splitFunctionsAndInheritedAccessors(
-                properties = descriptorsWithKind.properties,
-                functions = descriptorsWithKind.functions
-            )
-
-            val functions = async { regularFunctions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform, accessors) }
-            val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-            val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
-            val constructors = async {
-                descriptor.constructors.parallelMap {
-                    visitConstructorDescriptor(
-                        it,
-                        if (it.isPrimary) DRIWithPlatformInfo(driWithPlatform.dri, actual)
-                        else DRIWithPlatformInfo(driWithPlatform.dri, emptyMap())
-                    )
-                }
-            }
-
-            DClass(
-                dri = driWithPlatform.dri,
-                name = descriptor.name.asString(),
-                constructors = constructors.await(),
-                functions = functions.await(),
-                properties = properties.await(),
-                classlikes = classlikes.await(),
-                sources = actual,
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
-                supertypes = info.supertypes.toSourceSetDependent(),
-                generics = generics.await(),
-                documentation = info.docs,
-                modifier = descriptor.modifier().toSourceSetDependent(),
-                companion = descriptor.companion(driWithPlatform),
-                sourceSets = setOf(sourceSet),
-                isExpectActual = (isExpect || isActual),
-                extra = PropertyContainer.withAll(
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    descriptor.getAnnotations().toSourceSetDependent().toAnnotations(),
-                    ImplementedInterfaces(info.ancestry.allImplementedInterfaces().toSourceSetDependent()),
-                    info.ancestry.exceptionInSupertypesOrNull()
-                )
-            )
-        }
-    }
-
-    /**
-     * @param implicitAccessors getters/setters that are not part of the property descriptor, for instance
-     *                          average methods inherited from java sources that access the property
-     */
-    private suspend fun visitPropertyDescriptor(
-        originalDescriptor: PropertyDescriptor,
-        implicitAccessors: DescriptorAccessorHolder?,
-        parent: DRIWithPlatformInfo
-    ): DProperty {
-        val (dri, _) = originalDescriptor.createDRI()
-        val inheritedFrom = dri.getInheritedFromDRI(parent)
-        val descriptor = originalDescriptor.getConcreteDescriptor()
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-
-        val actual = originalDescriptor.createSources()
-
-        // example - generated getter that comes with data classes
-        suspend fun getDescriptorGetter() =
-            descriptor.accessors
-                .firstIsInstanceOrNull<PropertyGetterDescriptor>()
-                ?.let {
-                    visitPropertyAccessorDescriptor(it, descriptor, dri, inheritedFrom)
-                }
-
-        suspend fun getImplicitAccessorGetter() =
-            implicitAccessors?.getter?.let { visitFunctionDescriptor(it, parent) }
-
-        // example - generated setter that comes with data classes
-        suspend fun getDescriptorSetter() =
-            descriptor.accessors
-                .firstIsInstanceOrNull<PropertySetterDescriptor>()
-                ?.let {
-                    visitPropertyAccessorDescriptor(it, descriptor, dri, inheritedFrom)
-                }
-
-        suspend fun getImplicitAccessorSetter() =
-            implicitAccessors?.setter?.let { visitFunctionDescriptor(it, parent) }
-
-        return coroutineScope {
-            val generics = async { descriptor.typeParameters.parallelMap { it.toVariantTypeParameter() } }
-            val getter = getDescriptorGetter() ?: getImplicitAccessorGetter()
-            val setter = getDescriptorSetter() ?: getImplicitAccessorSetter()
-
-            DProperty(
-                dri = dri,
-                name = descriptor.name.asString(),
-                receiver = descriptor.extensionReceiverParameter?.let {
-                    visitReceiverParameterDescriptor(it, DRIWithPlatformInfo(dri, actual))
-                },
-                sources = actual,
-                getter = getter,
-                setter = setter,
-                visibility = descriptor.getVisibility(implicitAccessors).toSourceSetDependent(),
-                documentation = descriptor.resolveDescriptorData(),
-                modifier = descriptor.modifier().toSourceSetDependent(),
-                type = descriptor.returnType!!.toBound(),
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                sourceSets = setOf(sourceSet),
-                generics = generics.await(),
-                isExpectActual = (isExpect || isActual),
-                extra = PropertyContainer.withAll(
-                    listOfNotNull(
-                        (descriptor.additionalExtras() + descriptor.getAnnotationsWithBackingField()
-                            .toAdditionalExtras()).toSet().toSourceSetDependent().toAdditionalModifiers(),
-                        (descriptor.getAnnotationsWithBackingField() + descriptor.fileLevelAnnotations()).toSourceSetDependent()
-                            .toAnnotations(),
-                        descriptor.getDefaultValue()?.let { DefaultValue(it.toSourceSetDependent()) },
-                        inheritedFrom?.let { InheritedMember(it.toSourceSetDependent()) },
-                        takeIf { descriptor.isVar(getter, setter) }?.let { IsVar },
-                    )
-                )
-            )
-        }
-    }
-
-    private fun PropertyDescriptor.isVar(getter: DFunction?, setter: DFunction?): Boolean {
-        return if (this is JavaPropertyDescriptor) {
-            // in Java, concepts of extensibility and mutability are mixed into a single `final` modifier
-            // in Kotlin, it's different - val/var controls mutability and open modifier controls extensibility
-            // so when inheriting Java properties, you can end up with a final var - non extensible mutable prop
-            val isMutable = this.isVar
-            // non-final java property should be var if it has no accessors at all or has a setter
-            (isMutable && getter == null && setter == null) || (getter != null && setter != null)
-        } else {
-            this.isVar
-        }
-    }
-
-    private fun PropertyDescriptor.getVisibility(implicitAccessors: DescriptorAccessorHolder?): Visibility {
-        val isNonPublicJavaProperty = this is JavaPropertyDescriptor && !this.visibility.isPublicAPI
-        val visibility =
-            if (isNonPublicJavaProperty) {
-                // only try to take implicit getter's visibility if it's a java property
-                // because it's not guaranteed that implicit accessor will be used
-                // for the kotlin property, as it may have an explicit accessor of its own,
-                // i.e in data classes or with get() and set() are overridden
-                (implicitAccessors?.getter?.visibility ?: this.visibility)
-            } else {
-                this.visibility
-            }
-
-        return visibility.toDokkaVisibility()
-    }
-
-    private fun CallableMemberDescriptor.createDRI(wasOverridenBy: DRI? = null): Pair<DRI, DRI?> =
-        if (kind == CallableMemberDescriptor.Kind.DECLARATION || overriddenDescriptors.isEmpty())
-            Pair(DRI.from(this), wasOverridenBy)
-        else
-            overriddenDescriptors.first().createDRI(DRI.from(this))
-
-    private suspend fun visitFunctionDescriptor(
-        originalDescriptor: FunctionDescriptor,
-        parent: DRIWithPlatformInfo
-    ): DFunction {
-        val (dri, _) = originalDescriptor.createDRI()
-        val inheritedFrom = dri.getInheritedFromDRI(parent)
-        val descriptor = originalDescriptor.getConcreteDescriptor()
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-
-        val actual = originalDescriptor.createSources()
-        return coroutineScope {
-            val generics = async { descriptor.typeParameters.parallelMap { it.toVariantTypeParameter() } }
-
-            DFunction(
-                dri = dri,
-                name = descriptor.name.asString(),
-                isConstructor = false,
-                receiver = descriptor.extensionReceiverParameter?.let {
-                    visitReceiverParameterDescriptor(it, DRIWithPlatformInfo(dri, actual))
-                },
-                parameters = descriptor.valueParameters.mapIndexed { index, desc ->
-                    parameter(index, desc, DRIWithPlatformInfo(dri, actual))
-                },
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                sources = actual,
-                visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
-                generics = generics.await(),
-                documentation = descriptor.getDocumentation(),
-                modifier = descriptor.modifier().toSourceSetDependent(),
-                type = descriptor.returnType!!.toBound(),
-                sourceSets = setOf(sourceSet),
-                isExpectActual = (isExpect || isActual),
-                extra = PropertyContainer.withAll(
-                    inheritedFrom?.let { InheritedMember(it.toSourceSetDependent()) },
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    (descriptor.getAnnotations() + descriptor.fileLevelAnnotations()).toSourceSetDependent()
-                        .toAnnotations(),
-                    ObviousMember.takeIf { descriptor.isObvious() },
-                )
-            )
-        }
-    }
-
-    private fun FunctionDescriptor.getDocumentation(): SourceSetDependent<DocumentationNode> {
-        val isSynthesized = this.kind == CallableMemberDescriptor.Kind.SYNTHESIZED
-        return if (isSynthesized) {
-            syntheticDocProvider.getDocumentation(this)?.toSourceSetDependent() ?: emptyMap()
-        } else {
-            this.resolveDescriptorData()
-        }
-    }
-
-    /**
-     * `createDRI` returns the DRI of the exact element and potential DRI of an element that is overriding it
-     * (It can be also FAKE_OVERRIDE which is in fact just inheritance of the symbol)
-     *
-     * Looking at what PSIs do, they give the DRI of the element within the classnames where it is actually
-     * declared and inheritedFrom as the same DRI but truncated callable part.
-     * Therefore, we set callable to null and take the DRI only if it is indeed coming from different class.
-     */
-    private fun DRI.getInheritedFromDRI(parent: DRIWithPlatformInfo): DRI? {
-        return this.copy(callable = null)
-            .takeIf { parent.dri.classNames != this.classNames || parent.dri.packageName != this.packageName }
-    }
-
-    private fun FunctionDescriptor.isObvious(): Boolean {
-        return kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE
-                || (kind == CallableMemberDescriptor.Kind.SYNTHESIZED && !syntheticDocProvider.isDocumented(this))
-                || containingDeclaration.fqNameOrNull()?.isObvious() == true
-    }
-
-    private fun FqName.isObvious(): Boolean = with(this.asString()) {
-            return this == "kotlin.Any" || this == "kotlin.Enum"
-                    || this == "java.lang.Object" || this == "java.lang.Enum"
-    }
-
-    suspend fun visitConstructorDescriptor(descriptor: ConstructorDescriptor, parent: DRIWithPlatformInfo): DFunction {
-        val name = descriptor.constructedClass.name.toString()
-        val dri = parent.dri.copy(callable = Callable.from(descriptor, name))
-        val actual = descriptor.createSources()
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-
-        return coroutineScope {
-            val generics = async { descriptor.typeParameters.parallelMap { it.toVariantTypeParameter() } }
-
-            DFunction(
-                dri = dri,
-                name = name,
-                isConstructor = true,
-                receiver = descriptor.extensionReceiverParameter?.let {
-                    visitReceiverParameterDescriptor(it, DRIWithPlatformInfo(dri, actual))
-                },
-                parameters = descriptor.valueParameters.mapIndexed { index, desc ->
-                    parameter(index, desc, DRIWithPlatformInfo(dri, actual))
-                },
-                sources = actual,
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
-                documentation = descriptor.resolveDescriptorData().let { sourceSetDependent ->
-                    if (descriptor.isPrimary) {
-                        sourceSetDependent.map { entry ->
-                            Pair(
-                                entry.key,
-                                entry.value.copy(children = (entry.value.children.find { it is Constructor }?.root?.let { constructor ->
-                                    listOf(Description(constructor))
-                                } ?: emptyList<TagWrapper>()) + entry.value.children.filterIsInstance<Param>()))
-                        }.toMap()
-                    } else {
-                        sourceSetDependent
-                    }
-                },
-                type = descriptor.returnType.toBound(),
-                modifier = descriptor.modifier().toSourceSetDependent(),
-                generics = generics.await(),
-                sourceSets = setOf(sourceSet),
-                isExpectActual = (isExpect || isActual),
-                extra = PropertyContainer.withAll<DFunction>(
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    descriptor.getAnnotations().toSourceSetDependent().toAnnotations()
-                ).let {
-                    if (descriptor.isPrimary) {
-                        it + PrimaryConstructorExtra
-                    } else it
-                }
-            )
-        }
-    }
-
-    private suspend fun visitReceiverParameterDescriptor(
-        descriptor: ReceiverParameterDescriptor,
-        parent: DRIWithPlatformInfo
-    ) = DParameter(
-        dri = parent.dri.copy(target = PointingToDeclaration),
-        name = null,
-        type = descriptor.type.toBound(),
-        expectPresentInSet = null,
-        documentation = descriptor.resolveDescriptorData(),
-        sourceSets = setOf(sourceSet),
-        extra = PropertyContainer.withAll(descriptor.getAnnotations().toSourceSetDependent().toAnnotations())
-    )
-
-    private suspend fun visitPropertyAccessorDescriptor(
-        descriptor: PropertyAccessorDescriptor,
-        propertyDescriptor: PropertyDescriptor,
-        parent: DRI,
-        inheritedFrom: DRI? = null
-    ): DFunction {
-        val dri = parent.copy(callable = Callable.from(descriptor))
-        val isGetter = descriptor is PropertyGetterDescriptor
-        val isExpect = descriptor.isExpect
-        val isActual = descriptor.isActual
-
-        suspend fun PropertyDescriptor.asParameter(parent: DRI) =
-            DParameter(
-                parent.copy(target = PointingToCallableParameters(parameterIndex = 1)),
-                this.name.asString(),
-                type = this.type.toBound(),
-                expectPresentInSet = sourceSet.takeIf { isExpect },
-                documentation = descriptor.resolveDescriptorData(),
-                sourceSets = setOf(sourceSet),
-                extra = PropertyContainer.withAll(
-                    descriptor.additionalExtras().toSourceSetDependent().toAdditionalModifiers(),
-                    getAnnotationsWithBackingField().toSourceSetDependent().toAnnotations()
-                )
-            )
-
-        val name = run {
-            val rawName = propertyDescriptor.name.asString()
-            /*
-             * Kotlin has special rules for conversion around properties that
-             * start with "is" For more info see:
-             * h