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>

18 files changed, 1296 insertions, 0 deletions

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 {
+                            setOf(ExtraModifiers.JavaOnlyModifiers.Static)
+                        }
+                    )
+                    else setter.extra
+                )
+            }
+        )
+
+    private fun DFunction.asJava(
+        containingClassName: String,
+        newName: String,
+        parameters: List<DParameter>,
+        isTopLevel: Boolean = false
+    ): DFunction {
+        return copy(
+            dri = dri.copy(classNames = containingClassName, callable = dri.callable?.copy(name = newName)),
+            name = newName,
+            type = type.asJava(),
+            modifier = if (modifier.all { (_, v) -> v is KotlinModifier.Final } && isConstructor)
+                sourceSets.associateWith { JavaModifier.Empty }
+            else sourceSets.associateWith { modifier.values.first() },
+            parameters = listOfNotNull(receiver?.asJava()) + parameters.map { it.asJava() },
+            visibility = visibility.map { (sourceSet, visibility) -> Pair(sourceSet, visibility.asJava()) }.toMap(),
+            receiver = null,
+            extra = if (isTopLevel || isJvmStatic) {
+                extra + extra.mergeAdditionalModifiers(
+                    sourceSets.associateWith {
+                        setOf(ExtraModifiers.JavaOnlyModifiers.Static)
+                    }
+                )
+            } else {
+                extra
+            }
+        )
+    }
+
+    private fun DFunction.withJvmOverloads(
+        containingClassName: String,
+        newName: String,
+        isTopLevel: Boolean = false
+    ): List<DFunction>? {
+        val (paramsWithDefaults, paramsWithoutDefaults) = parameters
+            .withIndex()
+            .partition { (_, p) -> p.extra[DefaultValue] != null }
+        return paramsWithDefaults
+            .runningFold(paramsWithoutDefaults) { acc, param -> (acc + param) }
+            .map { params ->
+                asJava(
+                    containingClassName,
+                    newName,
+                    params
+                        .sortedBy(IndexedValue<DParameter>::index)
+                        .map { it.value },
+                    isTopLevel
+                )
+            }
+            .reversed()
+            .takeIf { it.isNotEmpty() }
+    }
+
+    internal fun DFunction.asJava(containingClassName: String, isTopLevel: Boolean = false): List<DFunction> {
+        val newName = when {
+            isConstructor -> containingClassName
+            else -> name
+        }
+        val baseFunction = asJava(containingClassName, newName, parameters, isTopLevel)
+        return if (hasJvmOverloads()) {
+            withJvmOverloads(containingClassName, newName, isTopLevel) ?: listOf(baseFunction)
+        } else {
+            listOf(baseFunction)
+        }
+    }
+
+    internal fun DClasslike.asJava(): DClasslike = when (this) {
+        is DClass -> asJava()
+        is DEnum -> asJava()
+        is DAnnotation -> asJava()
+        is DObject -> asJava()
+        is DInterface -> asJava()
+        else -> throw IllegalArgumentException("$this shouldn't be here")
+    }
+
+    internal fun DClass.asJava(): DClass = copy(
+        constructors = constructors
+            .filterNot { it.hasJvmSynthetic() }
+            .flatMap {
+                it.asJava(
+                    dri.classNames ?: name
+                )
+            }, // name may not always be valid here, however classNames should always be not null
+        functions = functionsInJava(),
+        properties = propertiesInJava(),
+        classlikes = classlikesInJava(),
+        generics = generics.map { it.asJava() },
+        companion = companion?.companionAsJava(),
+        supertypes = supertypes.mapValues { it.value.map { it.asJava() } },
+        modifier = if (modifier.all { (_, v) -> v is KotlinModifier.Empty }) sourceSets.associateWith { JavaModifier.Final }
+        else sourceSets.associateWith { modifier.values.first() }
+    )
+
+    /**
+     * Companion objects requires some custom logic for rendering as Java.
+     * They are excluded from usual classlikes rendering and added after.
+     */
+    internal fun DClass.classlikesInJava(): List<DClasslike> {
+        val classlikes = classlikes
+            .filter { it.name != companion?.name }
+            .map { it.asJava() }
+
+        val companionAsJava = companion?.companionAsJava()
+        return if (companionAsJava != null) classlikes.plus(companionAsJava) else classlikes
+    }
+
+
+    internal fun DClass.functionsInJava(): List<DFunction> =
+        properties
+            .filter { !it.isJvmField && !it.hasJvmSynthetic() }
+            .flatMap { property -> listOfNotNull(property.getter, property.setter) }
+            .plus(functions)
+            .plus(companion.staticFunctionsForJava())
+            .filterNot { it.hasJvmSynthetic() }
+            .flatMap { it.asJava(it.dri.classNames ?: it.name) }
+
+    internal fun DClass.propertiesInJava(): List<DProperty> {
+        val propertiesFromCompanion = companion
+            .staticPropertiesForJava()
+            .filterNot { it.hasJvmSynthetic() }
+            .map { it.asJava(isFromObjectOrCompanion = true) }
+        val companionInstanceProperty = companion?.companionInstancePropertyForJava()
+        val ownProperties = properties
+            .filterNot { it.hasJvmSynthetic() }
+            .map { it.asJava() }
+
+        return propertiesFromCompanion + ownProperties + listOfNotNull(companionInstanceProperty)
+    }
+
+    private fun DTypeParameter.asJava(): DTypeParameter = copy(
+        variantTypeParameter = variantTypeParameter.withDri(dri.possiblyAsJava()),
+        bounds = bounds.map { it.asJava() }
+    )
+
+    private fun Projection.asJava(): Projection = when (this) {
+        is Star -> Star
+        is Covariance<*> -> copy(inner.asJava())
+        is Contravariance<*> -> copy(inner.asJava())
+        is Invariance<*> -> copy(inner.asJava())
+        is Bound -> asJava()
+    }
+
+    private fun Bound.asJava(): Bound = when (this) {
+        is TypeParameter -> copy(dri.possiblyAsJava())
+        is GenericTypeConstructor -> copy(
+            dri = dri.possiblyAsJava(),
+            projections = projections.map { it.asJava() }
+        )
+
+        is FunctionalTypeConstructor -> copy(
+            dri = dri.possiblyAsJava(),
+            projections = projections.map { it.asJava() }
+        )
+
+        is TypeAliased -> copy(
+            typeAlias = typeAlias.asJava(),
+            inner = inner.asJava()
+        )
+
+        is Nullable -> copy(inner.asJava())
+        is DefinitelyNonNullable -> copy(inner.asJava())
+        is PrimitiveJavaType -> this
+        is Void -> this
+        is JavaObject -> this
+        is Dynamic -> this
+        is UnresolvedBound -> this
+    }
+
+    internal fun DEnum.asJava(): DEnum = copy(
+        constructors = constructors.flatMap { it.asJava(dri.classNames ?: name) },
+        functions = functions
+            .plus(
+                properties
+                    .filter { !it.isJvmField && !it.hasJvmSynthetic() }
+                    .flatMap { listOf(it.getter, it.setter) }
+            )
+            .filterNotNull()
+            .filterNot { it.hasJvmSynthetic() }
+            .flatMap { it.asJava(dri.classNames ?: name) },
+        properties = properties
+            .filterNot { it.hasJvmSynthetic() }
+            .map { it.asJava() },
+        classlikes = classlikes.map { it.asJava() },
+        supertypes = supertypes.mapValues { it.value.map { it.asJava() } }
+//    , entries = entries.map { it.asJava() }
+    )
+
+    /**
+     * Parameters [excludedProps] and [excludedFunctions] used for rendering companion objects
+     * where some members (that lifted to outer class) are not rendered
+     */
+    internal fun DObject.asJava(
+        excludedProps: List<DProperty> = emptyList(),
+        excludedFunctions: List<DFunction> = emptyList()
+    ): DObject = copy(
+        functions = functions
+            .plus(
+                properties
+                    .filterNot { it in excludedProps }
+                    .filter { !it.isJvmField && !it.isConst && !it.isLateInit && !it.hasJvmSynthetic() }
+                    .flatMap { listOf(it.getter, it.setter) }
+            )
+            .filterNotNull()
+            .filterNot { it in excludedFunctions }
+            .filterNot { it.hasJvmSynthetic() }
+            .flatMap { it.asJava(dri.classNames ?: name.orEmpty()) },
+        properties = properties
+            .filterNot { it.hasJvmSynthetic() }
+            .filterNot { it in excludedProps }
+            .map { it.asJava(isFromObjectOrCompanion = true) } +
+                DProperty(
+                    name = OBJECT_INSTANCE_NAME,
+                    modifier = sourceSets.associateWith { JavaModifier.Final },
+                    dri = dri.copy(callable = Callable(OBJECT_INSTANCE_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()
+                    })
+                ),
+        classlikes = classlikes.map { it.asJava() },
+        supertypes = supertypes.mapValues { it.value.map { it.asJava() } }
+    )
+
+    internal fun DInterface.asJava(): DInterface = copy(
+        functions = functions
+            .plus(
+                properties
+                    .filter { it.jvmField() == null && !it.hasJvmSynthetic() }
+                    .flatMap { listOf(it.getter, it.setter) }
+            )
+            .filterNotNull()
+            .filterNot { it.hasJvmSynthetic() }
+            .flatMap { it.asJava(dri.classNames ?: name) },
+        properties = emptyList(),
+        classlikes = classlikes.map { it.asJava() }, // TODO: public static final class DefaultImpls with impls for methods
+        generics = generics.map { it.asJava() },
+        supertypes = supertypes.mapValues { it.value.map { it.asJava() } }
+    )
+
+    internal fun DAnnotation.asJava(): DAnnotation = copy(
+        properties = properties.map { it.asJava() },
+        constructors = emptyList(),
+        classlikes = classlikes.map { it.asJava() }
+    ) // TODO investigate if annotation class can have methods and properties not from constructor
+
+    internal fun DParameter.asJava(): DParameter = copy(
+        type = type.asJava(),
+        name = if (name.isNullOrBlank()) "\$self" else name
+    )
+
+    internal fun Visibility.propertyVisibilityAsJava(): Visibility =
+        if (this is JavaVisibility) this
+        else JavaVisibility.Private
+
+    private fun TypeConstructor.possiblyAsJava(): TypeConstructor = when (this) {
+        is GenericTypeConstructor -> copy(dri = this.dri.possiblyAsJava())
+        is FunctionalTypeConstructor -> copy(dri = this.dri.possiblyAsJava())
+    }
+
+
+    internal fun TypeConstructorWithKind.asJava(): TypeConstructorWithKind =
+        TypeConstructorWithKind(
+            typeConstructor = typeConstructor.possiblyAsJava(),
+            kind = kind.asJava()
+        )
+
+    internal fun ClassKind.asJava(): ClassKind {
+        return when (this) {
+            is JavaClassKindTypes -> this
+            KotlinClassKindTypes.CLASS -> JavaClassKindTypes.CLASS
+            KotlinClassKindTypes.INTERFACE -> JavaClassKindTypes.INTERFACE
+            KotlinClassKindTypes.ENUM_CLASS -> JavaClassKindTypes.ENUM_CLASS
+            KotlinClassKindTypes.ENUM_ENTRY -> JavaClassKindTypes.ENUM_ENTRY
+            KotlinClassKindTypes.ANNOTATION_CLASS -> JavaClassKindTypes.ANNOTATION_CLASS
+            KotlinClassKindTypes.OBJECT -> JavaClassKindTypes.CLASS
+            else -> throw IllegalStateException("Non exchaustive match while trying to convert $this to Java")
+        }
+    }
+
+    private fun <T : Documentable> PropertyContainer<T>.mergeAdditionalModifiers(second: SourceSetDependent<Set<ExtraModifiers>>) =
+        this[AdditionalModifiers]?.squash(AdditionalModifiers(second)) ?: AdditionalModifiers(second)
+
+    private fun AdditionalModifiers.squash(second: AdditionalModifiers) =
+        AdditionalModifiers(content + second.content)
+
+    internal fun DObject.companionAsJava(): DObject? {
+        if (hasNothingToRender()) return null
+
+        return asJava(
+            excludedProps = staticPropertiesForJava(),
+            excludedFunctions = staticFunctionsForJava()
+        )
+    }
+
+    private fun DRI.possiblyAsJava(): DRI {
+        return kotlinToJavaMapper.findAsJava(this) ?: this
+    }
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmField.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmField.kt
new file mode 100644
index 00000000..3cf9b8fa
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmField.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
+
+import org.jetbrains.dokka.model.Annotations
+import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+
+internal fun <T : Documentable> WithExtraProperties<T>.jvmField(): Annotations.Annotation? =
+    extra[Annotations]?.directAnnotations?.entries?.firstNotNullOfOrNull { (_, annotations) -> annotations.jvmFieldAnnotation() }
+
+internal fun List<Annotations.Annotation>.jvmFieldAnnotation(): Annotations.Annotation? =
+    firstOrNull { it.dri.packageName == "kotlin.jvm" && it.dri.classNames == "JvmField" }
+
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmName.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmName.kt
new file mode 100644
index 00000000..6561f079
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmName.kt
@@ -0,0 +1,23 @@
+/*
+ * 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.model.Annotations
+import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.StringValue
+import org.jetbrains.dokka.model.isJvmName
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+
+internal fun <T : Documentable> WithExtraProperties<T>.directlyAnnotatedJvmName(): Annotations.Annotation? =
+    extra[Annotations]?.directAnnotations?.entries?.firstNotNullOfOrNull { (_, annotations)-> annotations.jvmNameAnnotation() }
+
+internal fun <T : Documentable> WithExtraProperties<T>.fileLevelJvmName(): Annotations.Annotation? =
+    extra[Annotations]?.fileLevelAnnotations?.entries?.firstNotNullOfOrNull { (_, annotations) -> annotations.jvmNameAnnotation() }
+
+internal fun List<Annotations.Annotation>.jvmNameAnnotation(): Annotations.Annotation? =
+    firstOrNull { it.isJvmName() }
+
+internal fun Annotations.Annotation.jvmNameAsString(): String? = (params["name"] as? StringValue)?.value
+
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmOverloads.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmOverloads.kt
new file mode 100644
index 00000000..08fbca07
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmOverloads.kt
@@ -0,0 +1,18 @@
+/*
+ * 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.model.Annotations
+import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+
+internal fun <T : Documentable> WithExtraProperties<T>.hasJvmOverloads(): Boolean {
+    return extra[Annotations]
+        ?.directAnnotations
+        ?.entries
+        ?.any { (_, annotations) ->
+            annotations.any { it.dri.packageName == "kotlin.jvm" && it.dri.classNames == "JvmOverloads" }
+        } == true
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmStatic.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmStatic.kt
new file mode 100644
index 00000000..a253dc83
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmStatic.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
+
+import org.jetbrains.dokka.model.Annotations
+import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+
+internal fun <T : Documentable> WithExtraProperties<T>.jvmStatic(): Annotations.Annotation? =
+    extra[Annotations]?.directAnnotations?.entries?.firstNotNullOfOrNull { (_, annotations) -> annotations.jvmStaticAnnotation() }
+
+internal fun List<Annotations.Annotation>.jvmStaticAnnotation(): Annotations.Annotation? =
+    firstOrNull { it.dri.packageName == "kotlin.jvm" && it.dri.classNames == "JvmStatic" }
+
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmSynthetic.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmSynthetic.kt
new file mode 100644
index 00000000..bf2a9ad1
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/jvmSynthetic.kt
@@ -0,0 +1,17 @@
+/*
+ * 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.model.Annotations
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+
+internal fun <T : org.jetbrains.dokka.model.AnnotationTarget> WithExtraProperties<T>.hasJvmSynthetic(): Boolean {
+    return extra[Annotations]
+        ?.directAnnotations
+        ?.entries
+        ?.any { (_, annotations) ->
+            annotations.any { it.dri.packageName == "kotlin.jvm" && it.dri.classNames == "JvmSynthetic" }
+        } == true
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureProvider.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureProvider.kt
new file mode 100644
index 00000000..e4c9d5dd
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureProvider.kt
@@ -0,0 +1,227 @@
+/*
+ * 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.signatures
+
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.signatures.JvmSignatureUtils
+import org.jetbrains.dokka.base.signatures.SignatureProvider
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
+import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+import org.jetbrains.dokka.pages.ContentKind
+import org.jetbrains.dokka.pages.ContentNode
+import org.jetbrains.dokka.pages.TextStyle
+import org.jetbrains.dokka.pages.TokenStyle
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.querySingle
+import org.jetbrains.dokka.utilities.DokkaLogger
+import kotlin.text.Typography.nbsp
+
+public class JavaSignatureProvider internal constructor(
+    ctcc: CommentsToContentConverter,
+    logger: DokkaLogger
+) : SignatureProvider, JvmSignatureUtils by JavaSignatureUtils {
+
+    public constructor(context: DokkaContext) : this(
+        context.plugin<DokkaBase>().querySingle { commentsToContentConverter },
+        context.logger
+    )
+
+    private val contentBuilder = PageContentBuilder(ctcc, this, logger)
+
+    private val ignoredVisibilities = setOf(JavaVisibility.Default)
+
+    private val ignoredModifiers =
+        setOf(KotlinModifier.Open, JavaModifier.Empty, KotlinModifier.Empty, KotlinModifier.Sealed)
+
+    override fun signature(documentable: Documentable): List<ContentNode> = when (documentable) {
+        is DFunction -> signature(documentable)
+        is DProperty -> signature(documentable)
+        is DClasslike -> signature(documentable)
+        is DEnumEntry -> signature(documentable)
+        is DTypeParameter -> signature(documentable)
+        else -> throw NotImplementedError(
+            "Cannot generate signature for ${documentable::class.qualifiedName} ${documentable.name}"
+        )
+    }
+
+    private fun signature(e: DEnumEntry) =
+        e.sourceSets.map {
+            contentBuilder.contentFor(
+                e,
+                ContentKind.Symbol,
+                setOf(TextStyle.Monospace),
+                sourceSets = setOf(it)
+            ) {
+                link(e.name, e.dri, styles = mainStyles + e.stylesIfDeprecated(it))
+            }
+        }
+
+    private fun signature(c: DClasslike) =
+        c.sourceSets.map { sourceSet ->
+            @Suppress("UNCHECKED_CAST")
+            val deprecationStyles = (c as? WithExtraProperties<out Documentable>)
+                ?.stylesIfDeprecated(sourceSet)
+                ?: emptySet()
+
+            contentBuilder.contentFor(
+                c,
+                ContentKind.Symbol,
+                setOf(TextStyle.Monospace),
+                sourceSets = setOf(sourceSet)
+            ) {
+                annotationsBlock(c)
+                c.visibility[sourceSet]?.takeIf { it !in ignoredVisibilities }?.name?.plus(" ")?.let { keyword(it) }
+
+                if (c is DClass) {
+                    c.modifier[sourceSet]?.takeIf { it !in ignoredModifiers }?.name?.plus(" ")?.let { keyword(it) }
+                    c.modifiers()[sourceSet]?.toSignatureString()?.let { keyword(it) }
+                }
+
+                when (c) {
+                    is DClass -> keyword("class ")
+                    is DInterface -> keyword("interface ")
+                    is DEnum -> keyword("enum ")
+                    is DObject -> keyword("class ")
+                    is DAnnotation -> keyword("@interface ")
+                }
+                link(c.name!!, c.dri, styles = mainStyles + deprecationStyles)
+                if (c is WithGenerics) {
+                    list(c.generics, prefix = "<", suffix = ">",
+                        separatorStyles = mainStyles + TokenStyle.Punctuation,
+                        surroundingCharactersStyle = mainStyles + TokenStyle.Operator) {
+                        +buildSignature(it)
+                    }
+                }
+                if (c is WithSupertypes) {
+                    c.supertypes.map { (p, dris) ->
+                        val (classes, interfaces) = dris.partition { it.kind == JavaClassKindTypes.CLASS }
+                        list(classes, prefix = " extends ", sourceSets = setOf(p),
+                            separatorStyles = mainStyles + TokenStyle.Punctuation,
+                            surroundingCharactersStyle = mainStyles + TokenStyle.Keyword) {
+                            signatureForProjection(it.typeConstructor)
+                        }
+                        list(interfaces, prefix = " implements ", sourceSets = setOf(p),
+                            separatorStyles = mainStyles + TokenStyle.Punctuation,
+                            surroundingCharactersStyle = mainStyles + TokenStyle.Keyword) {
+                            signatureForProjection(it.typeConstructor)
+                        }
+                    }
+                }
+            }
+        }
+
+    private fun signature(p: DProperty) =
+        p.sourceSets.map {
+            contentBuilder.contentFor(
+                p,
+                ContentKind.Symbol,
+                setOf(TextStyle.Monospace, TextStyle.Block),
+                sourceSets = setOf(it)
+            ) {
+                annotationsBlock(p)
+                p.visibility[it]?.takeIf { it !in ignoredVisibilities }?.name?.let { keyword("$it ") }
+                p.modifier[it]?.takeIf { it !in ignoredModifiers }?.name?.let { keyword("$it ") }
+                p.modifiers()[it]?.toSignatureString()?.let { keyword(it) }
+                signatureForProjection(p.type)
+                text(nbsp.toString())
+                link(p.name, p.dri, styles = mainStyles + p.stylesIfDeprecated(it))
+            }
+        }
+
+    private fun signature(f: DFunction) =
+        f.sourceSets.map { sourceSet ->
+            contentBuilder.contentFor(
+                f,
+                ContentKind.Symbol,
+                setOf(TextStyle.Monospace, TextStyle.Block),
+                sourceSets = setOf(sourceSet)
+            ) {
+                annotationsBlock(f)
+                f.visibility[sourceSet]?.takeIf { it !in ignoredVisibilities }?.name?.let { keyword("$it ") }
+                f.modifier[sourceSet]?.takeIf { it !in ignoredModifiers }?.name?.plus(" ")?.let { keyword(it) }
+                f.modifiers()[sourceSet]?.toSignatureString()?.let { keyword(it) }
+                val returnType = f.type
+                signatureForProjection(returnType)
+                text(nbsp.toString())
+                link(f.name, f.dri, styles = mainStyles + TokenStyle.Function + f.stylesIfDeprecated(sourceSet))
+                val usedGenerics = if (f.isConstructor) f.generics.filter { f uses it } else f.generics
+                list(usedGenerics, prefix = "<", suffix = ">",
+                    separatorStyles = mainStyles + TokenStyle.Punctuation,
+                    surroundingCharactersStyle = mainStyles + TokenStyle.Operator) {
+                    +buildSignature(it)
+                }
+                punctuation("(")
+                if (f.parameters.isNotEmpty()) {
+                    parametersBlock(f) {
+                        annotationsInline(it)
+                        text(it.modifiers()[sourceSet]?.toSignatureString() ?: "", styles = mainStyles + TokenStyle.Keyword)
+                        signatureForProjection(it.type)
+                        text(nbsp.toString())
+                        text(it.name!!)
+                    }
+                }
+                punctuation(")")
+            }
+        }
+
+    private fun signature(t: DTypeParameter) =
+        t.sourceSets.map {
+            contentBuilder.contentFor(t, sourceSets = setOf(it)) {
+                annotationsInline(t)
+                text(t.name.substringAfterLast("."), styles = mainStyles + t.stylesIfDeprecated(it))
+                list(
+                    elements = t.bounds,
+                    prefix = " extends ",
+                    separatorStyles = mainStyles + TokenStyle.Punctuation,
+                    surroundingCharactersStyle = mainStyles + TokenStyle.Keyword
+                ) {
+                    signatureForProjection(it)
+                }
+            }
+
+        }
+
+    private fun PageContentBuilder.DocumentableContentBuilder.signatureForProjection(p: Projection): Unit = when (p) {
+        is TypeParameter -> {
+            annotationsInline(p)
+            link(p.name, p.dri)
+        }
+
+        is TypeConstructor -> group(styles = emptySet()) {
+            annotationsInline(p)
+            link(p.dri.classNames.orEmpty(), p.dri)
+            list(p.projections, prefix = "<", suffix = ">",
+                separatorStyles = mainStyles + TokenStyle.Punctuation,
+                surroundingCharactersStyle = mainStyles + TokenStyle.Operator) {
+                signatureForProjection(it)
+            }
+        }
+
+        is Variance<*> -> group(styles = emptySet()) {
+            val variance = when(p) {
+                is Covariance<*> -> "? extends "
+                is Contravariance<*> -> "? super "
+                is Invariance<*> -> ""
+            }
+            keyword(variance)
+            signatureForProjection(p.inner)
+        }
+
+        is Star -> operator("?")
+
+        is Nullable -> signatureForProjection(p.inner)
+        is DefinitelyNonNullable -> signatureForProjection(p.inner)
+
+        is JavaObject, is Dynamic -> link("Object", DRI("java.lang", "Object"))
+        is Void -> text("void")
+        is PrimitiveJavaType -> text(p.name)
+        is UnresolvedBound -> text(p.name)
+        is TypeAliased -> signatureForProjection(p.inner)
+    }
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureUtils.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureUtils.kt
new file mode 100644
index 00000000..1738d40d
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/signatures/JavaSignatureUtils.kt
@@ -0,0 +1,44 @@
+/*
+ * 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.signatures
+
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.base.signatures.All
+import org.jetbrains.dokka.base.signatures.JvmSignatureUtils
+import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.AnnotationTarget
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+
+public object JavaSignatureUtils : JvmSignatureUtils {
+
+    private val ignoredAnnotations = setOf(
+        Annotations.Annotation(DRI("kotlin.jvm", "Transient"), emptyMap()),
+        Annotations.Annotation(DRI("kotlin.jvm", "Volatile"), emptyMap()),
+        Annotations.Annotation(DRI("kotlin.jvm", "Transitive"), emptyMap()),
+        Annotations.Annotation(DRI("kotlin.jvm", "Strictfp"), emptyMap()),
+        Annotations.Annotation(DRI("kotlin.jvm", "JvmStatic"), emptyMap())
+    )
+
+    private val strategy = All
+    private val listBrackets = Pair('{', '}')
+    private val classExtension = ".class"
+
+    override fun PageContentBuilder.DocumentableContentBuilder.annotationsBlock(d: AnnotationTarget) {
+        annotationsBlockWithIgnored(d, ignoredAnnotations, strategy, listBrackets, classExtension)
+    }
+
+    override fun PageContentBuilder.DocumentableContentBuilder.annotationsInline(d: AnnotationTarget) {
+        annotationsInlineWithIgnored(d, ignoredAnnotations, strategy, listBrackets, classExtension)
+    }
+
+    override fun <T : Documentable> WithExtraProperties<T>.modifiers(): Map<DokkaConfiguration.DokkaSourceSet, Set<ExtraModifiers.JavaOnlyModifiers>> {
+        return extra[AdditionalModifiers]?.content?.entries?.associate {
+            it.key to it.value.filterIsInstance<ExtraModifiers.JavaOnlyModifiers>().toSet()
+        } ?: emptyMap()
+    }
+
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformToJava.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformToJava.kt
new file mode 100644
index 00000000..32344dd9
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformToJava.kt
@@ -0,0 +1,42 @@
+/*
+ * 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.kotlinAsJava.converters.KotlinToJavaConverter
+import org.jetbrains.dokka.kotlinAsJava.transformers.JvmNameDocumentableTransformer
+import org.jetbrains.dokka.model.DClasslike
+import org.jetbrains.dokka.model.DFunction
+import org.jetbrains.dokka.model.DPackage
+import org.jetbrains.dokka.model.DProperty
+import org.jetbrains.dokka.plugability.DokkaContext
+
+private val JVM_NAME_DOCUMENTABLE_TRANSFORMER by lazy {
+    JvmNameDocumentableTransformer()
+}
+
+public fun DPackage.transformToJava(context: DokkaContext): DPackage {
+    with(KotlinToJavaConverter(context)) {
+        return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this@transformToJava.asJava(), context)
+    }
+}
+
+public fun DClasslike.transformToJava(context: DokkaContext): DClasslike {
+    with(KotlinToJavaConverter(context)) {
+        return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this@transformToJava.asJava(), context)
+    }
+}
+
+public fun DFunction.transformToJava(context: DokkaContext, containingClassName: String, isTopLevel: Boolean = false): List<DFunction> {
+    with(KotlinToJavaConverter(context)) {
+        return this@transformToJava.asJava(containingClassName, isTopLevel)
+            .map { JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(it, context) }
+    }
+}
+
+public fun DProperty.transformToJava(context: DokkaContext, isTopLevel: Boolean = false, relocateToClass: String? = null): DProperty {
+    with(KotlinToJavaConverter(context)) {
+        return JVM_NAME_DOCUMENTABLE_TRANSFORMER.transform(this@transformToJava.asJava(isTopLevel, relocateToClass), context)
+    }
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameDocumentableTransformer.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameDocumentableTransformer.kt
new file mode 100644
index 00000000..fe625e1c
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameDocumentableTransformer.kt
@@ -0,0 +1,116 @@
+/*
+ * 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.transformers
+
+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
+
+public 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) })
+    }
+
+    internal fun <T : Documentable> transform(documentable: T, context: DokkaContext): T {
+        val transformResult = 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) },
+                )
+                is DFunction -> {
+                    val name = jvmNameProvider.nameFor(this)
+                    copy(
+                        dri = documentable.dri.withCallableName(name),
+                        name = name,
+                        extra = extra.withoutJvmName()
+                    )
+                }
+                is DProperty -> transformGetterAndSetter(this)
+                is DClasslike -> transformClassLike(this, context)
+                is DEnumEntry -> copy(
+                    functions = functions.map { transform(it, context) },
+                    properties = properties.map { transform(it, context) },
+                    classlikes = classlikes.map { transform(it, context) },
+                )
+                else -> {
+                    context.logger.warn("Failed to translate a JvmName for ${this.javaClass.canonicalName}")
+                    this
+                }
+            }
+        }
+        @Suppress("UNCHECKED_CAST")
+        return transformResult as T
+    }
+
+    private fun PropertyContainer<DFunction>.withoutJvmName(): PropertyContainer<DFunction> {
+        val annotationsWithoutJvmName = get(Annotations)?.let { annotations ->
+            annotations.copy((annotations.directAnnotations).map { (sourceset, annotations) ->
+                sourceset to annotations.filterNot { it.isJvmName() }
+            }.toMap() + annotations.fileLevelAnnotations)
+        }
+        val extraWithoutAnnotations: PropertyContainer<DFunction> = minus(Annotations)
+
+        return extraWithoutAnnotations.addAll(listOfNotNull(annotationsWithoutJvmName))
+    }
+
+    private fun transformClassLike(documentable: DClasslike, context: DokkaContext): 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) },
+                )
+                is DAnnotation -> copy(
+                    functions = functions.map { transform(it, context) },
+                    properties = properties.map { transform(it, context) },
+                    classlikes = classlikes.map { transform(it, context) },
+                )
+                is DObject -> copy(
+                    functions = functions.map { transform(it, context) },
+                    properties = properties.map { transform(it, context) },
+                    classlikes = classlikes.map { transform(it, context) },
+                )
+                is DEnum -> copy(
+                    functions = functions.map { transform(it, context) },
+                    properties = properties.map { transform(it, context) },
+                    classlikes = classlikes.map { transform(it, context) },
+                )
+                is DInterface -> copy(
+                    functions = functions.map { transform(it, context) },
+                    properties = properties.map { transform(it, context) },
+                    classlikes = classlikes.map { transform(it, context) },
+                )
+            }
+        }
+
+    private fun transformGetterAndSetter(entry: DProperty): DProperty =
+        with(entry) {
+            copy(
+                setter = jvmNameProvider.nameForSetter(this)?.let { setterName ->
+                    setter?.let { setter ->
+                        setter.copy(
+                            dri = setter.dri.withCallableName(setterName),
+                            name = setterName,
+                            extra = setter.extra.withoutJvmName()
+                        )
+                    }
+                },
+                getter = jvmNameProvider.nameForGetter(this)?.let { getterName ->
+                    getter?.let { getter ->
+                        getter.copy(
+                            dri = getter.dri.withCallableName(getterName),
+                            name = getterName,
+                            extra = getter.extra.withoutJvmName()
+                        )
+                    }
+                })
+        }
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameProvider.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameProvider.kt
new file mode 100644
index 00000000..caf76b68
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameProvider.kt
@@ -0,0 +1,37 @@
+/*
+ * 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.transformers
+
+import org.jetbrains.dokka.kotlinAsJava.directlyAnnotatedJvmName
+import org.jetbrains.dokka.kotlinAsJava.fileLevelJvmName
+import org.jetbrains.dokka.kotlinAsJava.jvmNameAsString
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.properties.WithExtraProperties
+
+public data class Name(val fqName: String) {
+    val name: String = fqName.substringAfterLast(".")
+}
+
+public class JvmNameProvider {
+    public fun <T> nameFor(entry: T): String where T : Documentable, T : WithExtraProperties<T> =
+        entry.directlyAnnotatedJvmName()?.jvmNameAsString()
+            ?: entry.name
+            ?: throw IllegalStateException("Failed to provide a name for ${entry.javaClass.canonicalName}")
+
+    public fun <T> nameForSyntheticClass(entry: T): Name where T : WithSources, T : WithExtraProperties<T>, T : Documentable {
+        val name: String = (entry.fileLevelJvmName()?.params?.get("name") as? StringValue)?.value
+            ?: (entry.sources.entries.first().value.path.split("/").last().split(".").first().capitalize() + "Kt")
+        return Name("${entry.dri.packageName}.$name")
+    }
+
+    public fun nameForGetter(entry: DProperty): String? =
+        entry.getter?.directlyAnnotatedJvmName()?.jvmNameAsString()
+
+    public fun nameForSetter(entry: DProperty): String? =
+        entry.setter?.directlyAnnotatedJvmName()?.jvmNameAsString()
+
+    private fun List<Annotations.Annotation>.jvmNameAnnotation(): Annotations.Annotation? =
+        firstOrNull { it.isJvmName() }
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/KotlinAsJavaDocumentableTransformer.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/KotlinAsJavaDocumentableTransformer.kt
new file mode 100644
index 00000000..45682ea4
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/KotlinAsJavaDocumentableTransformer.kt
@@ -0,0 +1,19 @@
+/*
+ * 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.transformers
+
+import org.jetbrains.dokka.kotlinAsJava.converters.KotlinToJavaConverter
+import org.jetbrains.dokka.model.DModule
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer
+
+public class KotlinAsJavaDocumentableTransformer : DocumentableTransformer {
+    override fun invoke(original: DModule, context: DokkaContext): DModule =
+        original.copy(packages = original.packages.map {
+            with(KotlinToJavaConverter(context)) {
+                it.asJava()
+            }
+        })
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/withCallableName.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/withCallableName.kt
new file mode 100644
index 00000000..d2f5a9cf
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/withCallableName.kt
@@ -0,0 +1,9 @@
+/*
+ * 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.transformers
+
+import org.jetbrains.dokka.links.DRI
+
+internal fun DRI.withCallableName(newName: String): DRI = copy(callable = callable?.copy(name = newName))
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/translators/KotlinAsJavaDocumentableToPageTranslator.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/translators/KotlinAsJavaDocumentableToPageTranslator.kt
new file mode 100644
index 00000000..a0ed24d4
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/translators/KotlinAsJavaDocumentableToPageTranslator.kt
@@ -0,0 +1,35 @@
+/*
+ * 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.translators
+
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.DokkaBaseConfiguration
+import org.jetbrains.dokka.model.DModule
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.plugability.*
+import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator
+import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.dokka.analysis.kotlin.internal.InternalKotlinAnalysisPlugin
+
+public class KotlinAsJavaDocumentableToPageTranslator(
+    context: DokkaContext
+) : DocumentableToPageTranslator {
+    private val configuration = configuration<DokkaBase, DokkaBaseConfiguration>(context)
+    private val commentsToContentConverter = context.plugin<DokkaBase>().querySingle { commentsToContentConverter }
+    private val signatureProvider = context.plugin<DokkaBase>().querySingle { signatureProvider }
+    private val customTagContentProviders = context.plugin<DokkaBase>().query { customTagContentProvider }
+    private val documentableSourceLanguageParser = context.plugin<InternalKotlinAnalysisPlugin>().querySingle { documentableSourceLanguageParser }
+    private val logger: DokkaLogger = context.logger
+
+    override fun invoke(module: DModule): ModulePageNode =
+        KotlinAsJavaPageCreator(
+            configuration,
+            commentsToContentConverter,
+            signatureProvider,
+            logger,
+            customTagContentProviders,
+            documentableSourceLanguageParser
+        ).pageForModule(module)
+}
diff --git a/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/translators/KotlinAsJavaPageCreator.kt b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/translators/KotlinAsJavaPageCreator.kt
new file mode 100644
index 00000000..fcdc1d83
--- /dev/null
+++ b/dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/translators/KotlinAsJavaPageCreator.kt
@@ -0,0 +1,33 @@
+/*
+ * 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.translators
+
+import org.jetbrains.dokka.base.DokkaBaseConfiguration
+import org.jetbrains.dokka.base.signatures.SignatureProvider
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
+import org.jetbrains.dokka.base.transformers.pages.tags.CustomTagContentProvider
+import org.jetbrains.dokka.base.translators.documentables.DefaultPageCreator
+import org.jetbrains.dokka.model.DProperty
+import org.jetbrains.dokka.pages.MemberPageNode
+import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.dokka.analysis.kotlin.internal.DocumentableSourceLanguageParser
+
+public class KotlinAsJavaPageCreator(
+    configuration: DokkaBaseConfiguration?,
+    commentsToContentConverter: CommentsToContentConverter,
+    signatureProvider: SignatureProvider,
+    logger: DokkaLogger,
+    customTagContentProviders: List<CustomTagContentProvider>,
+    documentableAnalyzer: DocumentableSourceLanguageParser
+) : DefaultPageCreator(
+    configuration,
+    commentsToContentConverter,
+    signatureProvider,
+    logger,
+    customTagContentProviders = customTagContentProviders,
+    documentableAnalyzer = documentableAnalyzer
+) {
+    override fun pageForProperty(p: DProperty): MemberPageNode? = null
+}