Restructure the project to utilize included builds (#3174)

* Refactor and simplify artifact publishing
* Update Gradle to 8.4
* Refactor and simplify convention plugins and build scripts

Fixes #3132

---------

Co-authored-by: Adam <897017+aSemy@users.noreply.github.com>
Co-authored-by: Oleg Yukhnevich <whyoleg@gmail.com>

30 files changed, 3375 insertions, 0 deletions

diff --git a/dokka-subprojects/plugin-kotlin-as-java/README.md b/dokka-subprojects/plugin-kotlin-as-java/README.md
new file mode 100644
index 00000000..e33bd1bb
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/README.md
@@ -0,0 +1,15 @@
+# Kotlin as Java plugin
+
+With Kotlin as Java plugin applied, all Kotlin signatures will be rendered as Java signatures.
+
+For instance, `fun foo(bar: Bar): Baz` will be rendered as `public final Baz foo(Bar bar)`.
+
+The Kotlin as Java plugin is published to maven central as a
+[separate artifact](https://mvnrepository.com/artifact/org.jetbrains.dokka/kotlin-as-java-plugin):
+
+```text
+org.jetbrains.dokka:kotlin-as-java-plugin:1.9.10
+```
+
+**This plugin is at its early stages**, so you may experience issues and encounter bugs. Feel free to
+[report](https://github.com/Kotlin/dokka/issues/new/choose) any errors you see.
diff --git a/dokka-subprojects/plugin-kotlin-as-java/api/plugin-kotlin-as-java.api b/dokka-subprojects/plugin-kotlin-as-java/api/plugin-kotlin-as-java.api
new file mode 100644
index 00000000..e7766e36
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/api/plugin-kotlin-as-java.api
@@ -0,0 +1,103 @@
+public final class org/jetbrains/dokka/kotlinAsJava/KotlinAsJavaPlugin : org/jetbrains/dokka/plugability/DokkaPlugin {
+	public fun <init> ()V
+	public final fun getJavaSignatureProvider ()Lorg/jetbrains/dokka/plugability/Extension;
+	public final fun getJvmNameTransformer ()Lorg/jetbrains/dokka/plugability/Extension;
+	public final fun getKotlinAsJavaDocumentableToPageTranslator ()Lorg/jetbrains/dokka/plugability/Extension;
+	public final fun getKotlinAsJavaDocumentableTransformer ()Lorg/jetbrains/dokka/plugability/Extension;
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/TransformToJavaKt {
+	public static final fun transformToJava (Lorg/jetbrains/dokka/model/DClasslike;Lorg/jetbrains/dokka/plugability/DokkaContext;)Lorg/jetbrains/dokka/model/DClasslike;
+	public static final fun transformToJava (Lorg/jetbrains/dokka/model/DFunction;Lorg/jetbrains/dokka/plugability/DokkaContext;Ljava/lang/String;Z)Ljava/util/List;
+	public static final fun transformToJava (Lorg/jetbrains/dokka/model/DPackage;Lorg/jetbrains/dokka/plugability/DokkaContext;)Lorg/jetbrains/dokka/model/DPackage;
+	public static final fun transformToJava (Lorg/jetbrains/dokka/model/DProperty;Lorg/jetbrains/dokka/plugability/DokkaContext;ZLjava/lang/String;)Lorg/jetbrains/dokka/model/DProperty;
+	public static synthetic fun transformToJava$default (Lorg/jetbrains/dokka/model/DFunction;Lorg/jetbrains/dokka/plugability/DokkaContext;Ljava/lang/String;ZILjava/lang/Object;)Ljava/util/List;
+	public static synthetic fun transformToJava$default (Lorg/jetbrains/dokka/model/DProperty;Lorg/jetbrains/dokka/plugability/DokkaContext;ZLjava/lang/String;ILjava/lang/Object;)Lorg/jetbrains/dokka/model/DProperty;
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/converters/KotlinToJavaConverter {
+	public fun <init> (Lorg/jetbrains/dokka/plugability/DokkaContext;)V
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/converters/KotlinToJavaConverterKt {
+	public static final fun getJvmNameProvider ()Lorg/jetbrains/dokka/kotlinAsJava/transformers/JvmNameProvider;
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureProvider : org/jetbrains/dokka/base/signatures/JvmSignatureUtils, org/jetbrains/dokka/base/signatures/SignatureProvider {
+	public fun <init> (Lorg/jetbrains/dokka/plugability/DokkaContext;)V
+	public fun annotations (Lorg/jetbrains/dokka/model/DProperty;)Ljava/util/Map;
+	public fun annotations (Lorg/jetbrains/dokka/model/Documentable;)Ljava/util/Map;
+	public fun annotations (Lorg/jetbrains/dokka/model/properties/WithExtraProperties;)Ljava/util/Map;
+	public fun annotationsBlock (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/AnnotationTarget;)V
+	public fun annotationsBlockWithIgnored (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/AnnotationTarget;Ljava/util/Set;Lorg/jetbrains/dokka/base/signatures/AtStrategy;Lkotlin/Pair;Ljava/lang/String;)V
+	public fun annotationsInline (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/AnnotationTarget;)V
+	public fun annotationsInlineWithIgnored (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/AnnotationTarget;Ljava/util/Set;Lorg/jetbrains/dokka/base/signatures/AtStrategy;Lkotlin/Pair;Ljava/lang/String;)V
+	public fun modifiers (Lorg/jetbrains/dokka/model/properties/WithExtraProperties;)Ljava/util/Map;
+	public fun parametersBlock (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/DFunction;Lkotlin/jvm/functions/Function2;)V
+	public fun plus (Ljava/util/Map;Ljava/util/Map;)Ljava/util/Map;
+	public fun signature (Lorg/jetbrains/dokka/model/Documentable;)Ljava/util/List;
+	public fun stylesIfDeprecated (Lorg/jetbrains/dokka/model/properties/WithExtraProperties;Lorg/jetbrains/dokka/DokkaConfiguration$DokkaSourceSet;)Ljava/util/Set;
+	public fun toSignatureString (Ljava/util/Collection;)Ljava/lang/String;
+	public fun toSignatureString (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/Annotations$Annotation;Lorg/jetbrains/dokka/base/signatures/AtStrategy;Lkotlin/Pair;Ljava/lang/String;)V
+	public fun uses (Lorg/jetbrains/dokka/model/DFunction;Lorg/jetbrains/dokka/model/DTypeParameter;)Z
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureUtils : org/jetbrains/dokka/base/signatures/JvmSignatureUtils {
+	public static final field INSTANCE Lorg/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureUtils;
+	public fun annotations (Lorg/jetbrains/dokka/model/DProperty;)Ljava/util/Map;
+	public fun annotations (Lorg/jetbrains/dokka/model/Documentable;)Ljava/util/Map;
+	public fun annotations (Lorg/jetbrains/dokka/model/properties/WithExtraProperties;)Ljava/util/Map;
+	public fun annotationsBlock (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/AnnotationTarget;)V
+	public fun annotationsBlockWithIgnored (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/AnnotationTarget;Ljava/util/Set;Lorg/jetbrains/dokka/base/signatures/AtStrategy;Lkotlin/Pair;Ljava/lang/String;)V
+	public fun annotationsInline (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/AnnotationTarget;)V
+	public fun annotationsInlineWithIgnored (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/AnnotationTarget;Ljava/util/Set;Lorg/jetbrains/dokka/base/signatures/AtStrategy;Lkotlin/Pair;Ljava/lang/String;)V
+	public fun modifiers (Lorg/jetbrains/dokka/model/properties/WithExtraProperties;)Ljava/util/Map;
+	public fun parametersBlock (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/DFunction;Lkotlin/jvm/functions/Function2;)V
+	public fun plus (Ljava/util/Map;Ljava/util/Map;)Ljava/util/Map;
+	public fun stylesIfDeprecated (Lorg/jetbrains/dokka/model/properties/WithExtraProperties;Lorg/jetbrains/dokka/DokkaConfiguration$DokkaSourceSet;)Ljava/util/Set;
+	public fun toSignatureString (Ljava/util/Collection;)Ljava/lang/String;
+	public fun toSignatureString (Lorg/jetbrains/dokka/base/translators/documentables/PageContentBuilder$DocumentableContentBuilder;Lorg/jetbrains/dokka/model/Annotations$Annotation;Lorg/jetbrains/dokka/base/signatures/AtStrategy;Lkotlin/Pair;Ljava/lang/String;)V
+	public fun uses (Lorg/jetbrains/dokka/model/DFunction;Lorg/jetbrains/dokka/model/DTypeParameter;)Z
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameDocumentableTransformer : org/jetbrains/dokka/transformers/documentation/DocumentableTransformer {
+	public fun <init> ()V
+	public fun invoke (Lorg/jetbrains/dokka/model/DModule;Lorg/jetbrains/dokka/plugability/DokkaContext;)Lorg/jetbrains/dokka/model/DModule;
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameProvider {
+	public fun <init> ()V
+	public final fun nameFor (Lorg/jetbrains/dokka/model/Documentable;)Ljava/lang/String;
+	public final fun nameForGetter (Lorg/jetbrains/dokka/model/DProperty;)Ljava/lang/String;
+	public final fun nameForSetter (Lorg/jetbrains/dokka/model/DProperty;)Ljava/lang/String;
+	public final fun nameForSyntheticClass (Lorg/jetbrains/dokka/model/Documentable;)Lorg/jetbrains/dokka/kotlinAsJava/transformers/Name;
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/transformers/KotlinAsJavaDocumentableTransformer : org/jetbrains/dokka/transformers/documentation/DocumentableTransformer {
+	public fun <init> ()V
+	public fun invoke (Lorg/jetbrains/dokka/model/DModule;Lorg/jetbrains/dokka/plugability/DokkaContext;)Lorg/jetbrains/dokka/model/DModule;
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/transformers/Name {
+	public fun <init> (Ljava/lang/String;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun copy (Ljava/lang/String;)Lorg/jetbrains/dokka/kotlinAsJava/transformers/Name;
+	public static synthetic fun copy$default (Lorg/jetbrains/dokka/kotlinAsJava/transformers/Name;Ljava/lang/String;ILjava/lang/Object;)Lorg/jetbrains/dokka/kotlinAsJava/transformers/Name;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getFqName ()Ljava/lang/String;
+	public final fun getName ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/translators/KotlinAsJavaDocumentableToPageTranslator : org/jetbrains/dokka/transformers/documentation/DocumentableToPageTranslator {
+	public fun <init> (Lorg/jetbrains/dokka/plugability/DokkaContext;)V
+	public fun invoke (Lorg/jetbrains/dokka/model/DModule;)Lorg/jetbrains/dokka/pages/ModulePageNode;
+	public synthetic fun invoke (Lorg/jetbrains/dokka/model/DModule;)Lorg/jetbrains/dokka/pages/RootPageNode;
+}
+
+public final class org/jetbrains/dokka/kotlinAsJava/translators/KotlinAsJavaPageCreator : org/jetbrains/dokka/base/translators/documentables/DefaultPageCreator {
+	public fun <init> (Lorg/jetbrains/dokka/base/DokkaBaseConfiguration;Lorg/jetbrains/dokka/base/transformers/pages/comments/CommentsToContentConverter;Lorg/jetbrains/dokka/base/signatures/SignatureProvider;Lorg/jetbrains/dokka/utilities/DokkaLogger;Ljava/util/List;Lorg/jetbrains/dokka/analysis/kotlin/internal/DocumentableSourceLanguageParser;)V
+	public fun pageForProperty (Lorg/jetbrains/dokka/model/DProperty;)Lorg/jetbrains/dokka/pages/MemberPageNode;
+}
+
diff --git a/dokka-subprojects/plugin-kotlin-as-java/build.gradle.kts b/dokka-subprojects/plugin-kotlin-as-java/build.gradle.kts
new file mode 100644
index 00000000..4fdd5c12
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/build.gradle.kts
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+import dokkabuild.overridePublicationArtifactId
+
+plugins {
+    id("dokkabuild.kotlin-jvm")
+    id("dokkabuild.publish-jvm")
+    id("dokkabuild.test-k2")
+}
+
+overridePublicationArtifactId("kotlin-as-java-plugin")
+
+dependencies {
+    compileOnly(projects.dokkaSubprojects.dokkaCore)
+    compileOnly(projects.dokkaSubprojects.analysisKotlinApi)
+
+    implementation(projects.dokkaSubprojects.pluginBase)
+
+    implementation(kotlin("reflect"))
+
+    testImplementation(kotlin("test"))
+    testImplementation(libs.jsoup)
+    testImplementation(projects.dokkaSubprojects.pluginBase)
+    symbolsTestConfiguration(project(path = ":dokka-subprojects:analysis-kotlin-symbols", configuration = "shadow"))
+    descriptorsTestConfiguration(project(path = ":dokka-subprojects:analysis-kotlin-descriptors", configuration = "shadow"))
+    testImplementation(projects.dokkaSubprojects.pluginBaseTestUtils) {
+        exclude(module = "analysis-kotlin-descriptors")
+    }
+    testImplementation(projects.dokkaSubprojects.coreContentMatcherTestUtils)
+    testImplementation(projects.dokkaSubprojects.coreTestApi)
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/CollectionExtensions.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/CollectionExtensions.kt
new file mode 100644
index 00000000..3eab0aeb
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/CollectionExtensions.kt
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.kotlinAsJava
+
+// TODO [beresnev] remove this copy-paste and use the same method from stdlib instead after updating to 1.5
+internal inline fun <T, R : Any> Iterable<T>.firstNotNullOfOrNull(transform: (T) -> R?): R? {
+    for (element in this) {
+        val result = transform(element)
+        if (result != null) {
+            return result
+        }
+    }
+    return null
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/KotlinAsJavaPlugin.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/KotlinAsJavaPlugin.kt
new file mode 100644
index 00000000..36da34dc
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/KotlinAsJavaPlugin.kt
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.kotlinAsJava
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.signatures.SignatureProvider
+import org.jetbrains.dokka.kotlinAsJava.signatures.JavaSignatureProvider
+import org.jetbrains.dokka.kotlinAsJava.transformers.JvmNameDocumentableTransformer
+import org.jetbrains.dokka.kotlinAsJava.transformers.KotlinAsJavaDocumentableTransformer
+import org.jetbrains.dokka.kotlinAsJava.translators.KotlinAsJavaDocumentableToPageTranslator
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.plugability.DokkaPluginApiPreview
+import org.jetbrains.dokka.plugability.Extension
+import org.jetbrains.dokka.plugability.PluginApiPreviewAcknowledgement
+import org.jetbrains.dokka.renderers.PostAction
+import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator
+import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer
+
+public class KotlinAsJavaPlugin : DokkaPlugin() {
+    public val kotlinAsJavaDocumentableTransformer: Extension<DocumentableTransformer, *, *> by extending {
+        CoreExtensions.documentableTransformer with KotlinAsJavaDocumentableTransformer()
+    }
+
+    public val jvmNameTransformer: Extension<DocumentableTransformer, *, *> by extending {
+        CoreExtensions.documentableTransformer with JvmNameDocumentableTransformer() order {
+            after(kotlinAsJavaDocumentableTransformer)
+        }
+    }
+
+    public val javaSignatureProvider: Extension<SignatureProvider, *, *> by extending {
+        with(plugin<DokkaBase>()) {
+            signatureProvider providing ::JavaSignatureProvider override kotlinSignatureProvider
+        }
+    }
+
+    public val kotlinAsJavaDocumentableToPageTranslator: Extension<DocumentableToPageTranslator, *, *> by extending {
+        CoreExtensions.documentableToPageTranslator providing ::KotlinAsJavaDocumentableToPageTranslator override
+                plugin<DokkaBase>().documentableToPageTranslator
+    }
+
+    internal val alphaVersionNotifier by extending {
+        CoreExtensions.postActions providing { ctx ->
+            PostAction {
+                ctx.logger.info("KotlinAsJava plugin is in Alpha version, use at your own risk, expect bugs and migration issues")
+            }
+        }
+    }
+
+    @OptIn(DokkaPluginApiPreview::class)
+    override fun pluginApiPreviewAcknowledgement(): PluginApiPreviewAcknowledgement =
+        PluginApiPreviewAcknowledgement
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/converters/KotlinCompanion.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/converters/KotlinCompanion.kt
new file mode 100644
index 00000000..260fc25d
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/converters/KotlinCompanion.kt
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.kotlinAsJava.converters
+
+import org.jetbrains.dokka.links.Callable
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.properties.PropertyContainer
+
+private const val DEFAULT_COMPANION_NAME = "Companion"
+
+internal fun DObject?.staticFunctionsForJava(): List<DFunction> {
+    if (this == null) return emptyList()
+    return functions.filter { it.isJvmStatic }
+}
+
+/**
+ * @return properties that will be visible as static for java.
+ * See [Static fields](https://kotlinlang.org/docs/java-to-kotlin-interop.html#static-fields)
+ */
+internal fun DObject?.staticPropertiesForJava(): List<DProperty> {
+    if (this == null) return emptyList()
+    return properties.filter { it.isJvmField || it.isConst || it.isLateInit }
+}
+
+internal fun DObject.companionInstancePropertyForJava(): DProperty? {
+    if (hasNothingToRender()) return null // do not show if companion not rendered
+
+    return DProperty(
+        name = name ?: DEFAULT_COMPANION_NAME,
+        modifier = sourceSets.associateWith { JavaModifier.Final },
+        dri = dri.copy(callable = Callable(name ?: DEFAULT_COMPANION_NAME, null, emptyList())),
+        documentation = emptyMap(),
+        sources = emptyMap(),
+        visibility = sourceSets.associateWith {
+            JavaVisibility.Public
+        },
+        type = GenericTypeConstructor(dri, emptyList()),
+        setter = null,
+        getter = null,
+        sourceSets = sourceSets,
+        receiver = null,
+        generics = emptyList(),
+        expectPresentInSet = expectPresentInSet,
+        isExpectActual = false,
+        extra = PropertyContainer.withAll(sourceSets.map {
+            mapOf(it to setOf(ExtraModifiers.JavaOnlyModifiers.Static)).toAdditionalModifiers()
+        })
+    )
+}
+
+/**
+ * Hide companion object if there isn't members of parents.
+ * Properties and functions that are moved to outer class are not counted as members.
+ */
+internal fun DObject.hasNothingToRender(): Boolean {
+    val nonStaticPropsCount = properties.size - staticPropertiesForJava().size
+    val nonStaticFunctionsCount = functions.size - staticFunctionsForJava().size
+    val classLikesCount = classlikes.size
+    val superTypesCount = supertypes.values.firstOrNull()?.size ?: 0
+
+    return nonStaticFunctionsCount + nonStaticPropsCount +
+            classLikesCount + superTypesCount == 0
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/converters/KotlinToJavaConverter.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/converters/KotlinToJavaConverter.kt
new file mode 100644
index 00000000..a8b3a86c
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/converters/KotlinToJavaConverter.kt
@@ -0,0 +1,508 @@
+/*
+ * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package org.jetbrains.dokka.kotlinAsJava.converters
+
+import org.jetbrains.dokka.kotlinAsJava.*
+import org.jetbrains.dokka.kotlinAsJava.transformers.JvmNameProvider
+import org.jetbrains.dokka.kotlinAsJava.transformers.withCallableName
+import org.jetbrains.dokka.links.Callable
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.links.withClass
+import org.jetbrains.dokka.model.*
+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.analysis.kotlin.internal.InternalKotlinAnalysisPlugin
+
+public val jvmNameProvider: JvmNameProvider = JvmNameProvider()
+internal const val OBJECT_INSTANCE_NAME = "INSTANCE"
+
+internal val DProperty.isConst: Boolean
+    get() = hasModifier(ExtraModifiers.KotlinOnlyModifiers.Const)
+
+internal val DProperty.isLateInit: Boolean
+    get() = hasModifier(ExtraModifiers.KotlinOnlyModifiers.LateInit)
+
+internal val DProperty.isJvmField: Boolean
+    get() = jvmField() != null
+
+internal val DFunction.isJvmStatic: Boolean
+    get() = jvmStatic() != null
+
+private fun DProperty.hasModifier(modifier: ExtraModifiers.KotlinOnlyModifiers): Boolean =
+    extra[AdditionalModifiers]
+        ?.content
+        ?.any { (_, modifiers) -> modifier in modifiers } == true
+
+public class KotlinToJavaConverter(
+    private val context: DokkaContext
+) {
+    private val kotlinToJavaMapper by lazy {
+        context.plugin<InternalKotlinAnalysisPlugin>().querySingle { kotlinToJavaService }
+    }
+
+    internal fun DPackage.asJava(): DPackage {
+        val syntheticClasses =
+            (properties.map { jvmNameProvider.nameForSyntheticClass(it) to it }
+                    + functions.map { jvmNameProvider.nameForSyntheticClass(it) to it })
+                .groupBy({ it.first }) { it.second }
+                .map { (syntheticClassName, nodes) ->
+                    DClass(
+                        dri = dri.withClass(syntheticClassName.name),
+                        name = syntheticClassName.name,
+                        properties = nodes
+                            .filterIsInstance<DProperty>()
+                            .filterNot { it.hasJvmSynthetic() }
+                            .map { it.asJava(true) },
+                        constructors = emptyList(),
+                        functions = (
+                                nodes
+                                    .filterIsInstance<DProperty>()
+                                    .filterNot { it.isConst || it.isJvmField || it.hasJvmSynthetic() }
+                                    .flatMap { it.javaAccessors(relocateToClass = syntheticClassName.name) } +
+                                        nodes
+                                            .filterIsInstance<DFunction>()
+                                            .flatMap { it.asJava(syntheticClassName.name, true) })
+                            .filterNot { it.hasJvmSynthetic() },
+                        classlikes = emptyList(),
+                        sources = emptyMap(),
+                        expectPresentInSet = null,
+                        visibility = sourceSets.associateWith {
+                            JavaVisibility.Public
+                        },
+                        companion = null,
+                        generics = emptyList(),
+                        supertypes = emptyMap(),
+                        documentation = emptyMap(),
+                        modifier = sourceSets.associateWith { JavaModifier.Final },
+                        sourceSets = sourceSets,
+                        isExpectActual = false,
+                        extra = PropertyContainer.empty()
+                    )
+                }
+
+        return copy(
+            functions = emptyList(),
+            properties = emptyList(),
+            classlikes = classlikes.map { it.asJava() } + syntheticClasses,
+            typealiases = emptyList()
+        )
+    }
+
+    internal fun DProperty.asJava(
+        isTopLevel: Boolean = false,
+        relocateToClass: String? = null,
+        isFromObjectOrCompanion: Boolean = false
+    ) =
+        copy(
+            dri = if (relocateToClass.isNullOrBlank()) {
+                dri
+            } else {
+                dri.withClass(relocateToClass)
+            },
+            modifier = javaModifierFromSetter(),
+            visibility = visibility.mapValues {
+                if (isConst || isJvmField || (getter == null && setter == null) || (isFromObjectOrCompanion && isLateInit)) {
+                    it.value.asJava()
+                } else {
+                    it.value.propertyVisibilityAsJava()
+                }
+            },
+            type = type.asJava(), // TODO: check
+            setter = null,
+            getter = null, // Removing getters and setters as they will be available as functions
+            extra = if (isTopLevel || isConst || (isFromObjectOrCompanion && isJvmField) || (isFromObjectOrCompanion && isLateInit))
+                extra + extra.mergeAdditionalModifiers(
+                    sourceSets.associateWith {
+                        setOf(ExtraModifiers.JavaOnlyModifiers.Static)
+                    }
+                )
+            else extra
+        )
+
+    internal fun Visibility.asJava() =
+        when (this) {
+            is JavaVisibility -> this
+            is KotlinVisibility.Public, KotlinVisibility.Internal -> JavaVisibility.Public
+            is KotlinVisibility.Private -> JavaVisibility.Private
+            is KotlinVisibility.Protected -> JavaVisibility.Protected
+        }
+
+    internal fun DProperty.javaModifierFromSetter() =
+        modifier.mapValues {
+            when {
+                it.value is JavaModifier -> it.value
+                setter == null -> JavaModifier.Final
+                else -> JavaModifier.Empty
+            }
+        }
+
+    internal fun DProperty.javaAccessors(
+        isTopLevel: Boolean = false,
+        relocateToClass: String? = null
+    ): List<DFunction> =
+        listOfNotNull(
+            getter?.let { getter ->
+                val name = "get" + name.capitalize()
+                getter.copy(
+                    dri = if (relocateToClass.isNullOrBlank()) {
+                        getter.dri
+                    } else {
+                        getter.dri.withClass(relocateToClass)
+                    }.withCallableName(name),
+                    name = name,
+                    modifier = javaModifierFromSetter(),
+                    visibility = visibility.mapValues { JavaVisibility.Public },
+                    type = getter.type.asJava(),
+                    extra = if (isTopLevel) getter.extra +
+                            getter.extra.mergeAdditionalModifiers(
+                                sourceSets.associateWith {
+                                    setOf(ExtraModifiers.JavaOnlyModifiers.Static)
+                                }
+                            )
+                    else getter.extra
+                )
+            },
+            setter?.let { setter ->
+                val name = "set" + name.capitalize()
+                val baseDRI = (if (relocateToClass.isNullOrBlank()) {
+                    setter.dri
+                } else {
+                    setter.dri.withClass(relocateToClass)
+                }).withCallableName(name)
+                setter.copy(
+                    dri = baseDRI,
+                    name = name,
+                    parameters = setter.parameters.map {
+                        it.copy(
+                            dri = baseDRI.copy(
+                                target = it.dri.target,
+                                extra = it.dri.extra
+                            ), type = it.type.asJava()
+                        )
+                    },
+                    modifier = javaModifierFromSetter(),
+                    visibility = visibility.mapValues { JavaVisibility.Public },
+                    type = Void,
+                    extra = if (isTopLevel) setter.extra + setter.extra.mergeAdditionalModifiers(
+                        sourceSets.associateWith {