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>

54 files changed, 0 insertions, 36758 deletions

diff --git a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocDocumentableToPageTranslator.kt b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocDocumentableToPageTranslator.kt
deleted file mode 100644
index 595c307a..00000000
--- a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocDocumentableToPageTranslator.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc
-
-import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.pages.RootPageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator
-
-public class JavadocDocumentableToPageTranslator(
-    private val context: DokkaContext
-) : DocumentableToPageTranslator {
-    override fun invoke(module: DModule): RootPageNode = JavadocPageCreator(context).pageForModule(module)
-}
diff --git a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPageCreator.kt b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPageCreator.kt
deleted file mode 100644
index cfdda649..00000000
--- a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPageCreator.kt
+++ /dev/null
@@ -1,261 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc
-
-import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.base.signatures.SignatureProvider
-import org.jetbrains.dokka.base.transformers.pages.comments.DocTagToContentConverter
-import org.jetbrains.dokka.base.translators.documentables.firstSentenceBriefFromContentNodes
-import org.jetbrains.dokka.javadoc.pages.*
-import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.model.properties.WithExtraProperties
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.querySingle
-import kotlin.reflect.KClass
-
-public open class JavadocPageCreator(context: DokkaContext) {
-    private val signatureProvider: SignatureProvider = context.plugin<DokkaBase>().querySingle { signatureProvider }
-    private val documentationVersion = context.configuration.moduleVersion
-
-    public fun pageForModule(m: DModule): JavadocModulePageNode {
-        return JavadocModulePageNode(
-            name = m.name.ifEmpty { "root" },
-            content = contentForModule(m),
-            children = m.packages.map { pageForPackage(it) },
-            dri = setOf(m.dri),
-            extra = ((m as? WithExtraProperties<DModule>)?.extra ?: PropertyContainer.empty())
-        )
-    }
-
-    public fun pageForPackage(p: DPackage): JavadocPackagePageNode {
-        return JavadocPackagePageNode(p.name, contentForPackage(p), setOf(p.dri), listOf(p),
-            p.classlikes.mapNotNull { pageForClasslike(it) }
-        )
-    }
-
-    public fun pageForClasslike(c: DClasslike): JavadocClasslikePageNode? {
-        return c.highestJvmSourceSet?.let { jvm ->
-            @Suppress("UNCHECKED_CAST")
-            val extra = ((c as? WithExtraProperties<Documentable>)?.extra ?: PropertyContainer.empty())
-            val children = c.classlikes.mapNotNull { pageForClasslike(it) }
-
-            JavadocClasslikePageNode(
-                name = c.dri.classNames.orEmpty(),
-                content = contentForClasslike(c),
-                dri = setOf(c.dri),
-                brief = c.brief(),
-                signature = signatureForNode(c, jvm),
-                description = c.descriptionToContentNodes(),
-                constructors = (c as? WithConstructors)?.constructors?.mapNotNull { it.toJavadocFunction() }.orEmpty(),
-                methods = c.functions.mapNotNull { it.toJavadocFunction() },
-                entries = (c as? DEnum)?.entries?.map {
-                    JavadocEntryNode(
-                        it.dri,
-                        it.name,
-                        signatureForNode(it, jvm),
-                        it.descriptionToContentNodes(jvm),
-                        PropertyContainer.withAll(it.indexesInDocumentation())
-                    )
-                }.orEmpty(),
-                classlikes = children,
-                properties = c.properties.map {
-                    JavadocPropertyNode(
-                        it.dri,
-                        it.name,
-                        signatureForNode(it, jvm),
-                        it.descriptionToContentNodes(jvm),
-                        PropertyContainer.withAll(it.indexesInDocumentation()),
-                    )
-                },
-                sinceTagContent = c.sinceToContentNodes(jvm),
-                authorTagContent = c.authorsToContentNodes(jvm),
-                documentables = listOf(c),
-                children = children,
-                extra = extra + c.indexesInDocumentation()
-            )
-        }
-    }
-
-    private fun contentForModule(m: DModule): JavadocContentNode =
-        JavadocContentGroup(
-            setOf(m.dri),
-            JavadocContentKind.OverviewSummary,
-            m.sourceSets.toDisplaySourceSets()
-        ) {
-            title(m.name, m.descriptionToContentNodes(), documentationVersion, dri = setOf(m.dri), kind = ContentKind.Main)
-            leafList(setOf(m.dri),
-                ContentKind.Packages, JavadocList(
-                    "Packages", "Package",
-                    m.packages.sortedBy { it.packageName }.map { p ->
-                        RowJavadocListEntry(
-                            LinkJavadocListEntry(p.name, setOf(p.dri), JavadocContentKind.PackageSummary, sourceSets),
-                            p.brief()
-                        )
-                    }
-                ))
-        }
-
-    private fun contentForPackage(p: DPackage): JavadocContentNode =
-        JavadocContentGroup(
-            setOf(p.dri),
-            JavadocContentKind.PackageSummary,
-            p.sourceSets.toDisplaySourceSets()
-        ) {
-            title("Package ${p.name}", p.descriptionToContentNodes(), dri = setOf(p.dri), kind = ContentKind.Packages)
-            fun allClasslikes(c: DClasslike): List<DClasslike> = c.classlikes.flatMap { allClasslikes(it) } + c
-            val rootList = p.classlikes.map { allClasslikes(it) }.flatten().groupBy { it::class }.map { (key, value) ->
-                JavadocList(key.tabTitle, key.colTitle, value.map { c ->
-                    RowJavadocListEntry(
-                        LinkJavadocListEntry(c.name ?: "", setOf(c.dri), JavadocContentKind.Class, sourceSets),
-                        c.brief()
-                    )
-                })
-            }
-            rootList(setOf(p.dri), JavadocContentKind.Class, rootList)
-        }
-
-    private val KClass<out DClasslike>.colTitle: String
-        get() = when (this) {
-            DClass::class -> "Class"
-            DObject::class -> "Object"
-            DAnnotation::class -> "Annotation"
-            DEnum::class -> "Enum"
-            DInterface::class -> "Interface"
-            else -> ""
-        }
-
-    private val KClass<out DClasslike>.tabTitle: String
-        get() = "$colTitle Summary"
-
-    private fun contentForClasslike(c: DClasslike): JavadocContentNode =
-        JavadocContentGroup(
-            setOf(c.dri),
-            JavadocContentKind.Class,
-            c.sourceSets.toDisplaySourceSets()
-        ) {
-            title(
-                c.name.orEmpty(),
-                c.brief(),
-                documentationVersion,
-                parent = c.dri.packageName,
-                dri = setOf(c.dri),
-                kind = JavadocContentKind.Class
-            )
-        }
-
-    private fun DFunction.toJavadocFunction() = highestJvmSourceSet?.let { jvm ->
-        JavadocFunctionNode(
-            name = name,
-            dri = dri,
-            signature = signatureForNode(this, jvm),
-            brief = brief(jvm),
-            description = descriptionToContentNodes(jvm),
-            parameters = parameters.mapNotNull {
-                val signature = signatureForNode(it, jvm)
-                signature.modifiers?.let { type ->
-                    JavadocParameterNode(
-                        name = it.name.orEmpty(),
-                        type = type,
-                        description = it.brief(),
-                        typeBound = it.type,
-                        dri = it.dri,
-                        extra = PropertyContainer.withAll(it.indexesInDocumentation())
-                    )
-                }
-            },
-            returnTagContent = returnToContentNodes(jvm),
-            sinceTagContent = sinceToContentNodes(jvm),
-            extra = extra + indexesInDocumentation()
-        )
-    }
-
-    private val Documentable.highestJvmSourceSet
-        get() = sourceSets.let { sources ->
-            sources.firstOrNull { it != expectPresentInSet } ?: sources.firstOrNull()
-        }
-
-    private inline fun <reified T : TagWrapper> Documentable.findNodeInDocumentation(sourceSetData: DokkaSourceSet?): T? =
-        documentation[sourceSetData]?.firstChildOfTypeOrNull<T>()
-
-    private inline fun <reified T : TagWrapper> Documentable.findAllNodesInDocumentation(sourceSetData: DokkaSourceSet?): List<T> =
-        documentation[sourceSetData]?.childrenOfType<T>() ?: emptyList()
-
-    private fun Documentable.descriptionToContentNodes(sourceSet: DokkaSourceSet? = highestJvmSourceSet) =
-        contentNodesFromType<Description>(sourceSet)
-
-    private fun DParameter.paramsToContentNodes(sourceSet: DokkaSourceSet? = highestJvmSourceSet) =
-        contentNodesFromType<Param>(sourceSet)
-
-    private inline fun <reified T : TagWrapper> Documentable.contentNodesFromType(sourceSet: DokkaSourceSet?) =
-        findNodeInDocumentation<T>(sourceSet)?.let {
-            DocTagToContentConverter().buildContent(
-                it.root,
-                DCI(setOf(dri), JavadocContentKind.OverviewSummary),
-                sourceSets.toSet()
-            )
-        }.orEmpty()
-
-    private inline fun <reified T : TagWrapper> Documentable.allContentNodesFromType(sourceSet: DokkaSourceSet?) =
-        findAllNodesInDocumentation<T>(sourceSet).map {
-            DocTagToContentConverter().buildContent(
-                it.root,
-                DCI(setOf(dri), JavadocContentKind.OverviewSummary),
-                sourceSets.toSet()
-            )
-        }
-
-    public fun List<ContentNode>.nodeForJvm(jvm: DokkaSourceSet): ContentNode {
-        return firstOrNull { jvm.sourceSetID in it.sourceSets.computeSourceSetIds() }
-            ?: throw IllegalStateException("No source set found for ${jvm.sourceSetID} ")
-    }
-
-    private fun Documentable.brief(sourceSet: DokkaSourceSet? = highestJvmSourceSet): List<ContentNode> =
-        firstSentenceBriefFromContentNodes(descriptionToContentNodes(sourceSet))
-
-    private fun DParameter.brief(sourceSet: DokkaSourceSet? = highestJvmSourceSet): List<ContentNode> =
-        firstSentenceBriefFromContentNodes(paramsToContentNodes(sourceSet).dropWhile { it is ContentDRILink })
-
-    private fun ContentNode.asJavadocNode(): JavadocSignatureContentNode =
-        (this as ContentGroup).firstChildOfTypeOrNull<JavadocSignatureContentNode>()
-            ?: throw IllegalStateException("No content for javadoc signature found")
-
-    private fun signatureForNode(documentable: Documentable, sourceSet: DokkaSourceSet): JavadocSignatureContentNode =
-        signatureProvider.signature(documentable).nodeForJvm(sourceSet).asJavadocNode()
-
-    private fun Documentable.indexesInDocumentation(): JavadocIndexExtra {
-        val indexes =
-            documentation[highestJvmSourceSet]?.withDescendants()?.filterIsInstance<Index>()?.toList().orEmpty()
-        return JavadocIndexExtra(
-            indexes.map {
-                ContentGroup(
-                    children = DocTagToContentConverter().buildContent(
-                        it,
-                        DCI(setOf(dri), JavadocContentKind.OverviewSummary),
-                        sourceSets.toSet()
-                    ),
-                    dci = DCI(setOf(dri), JavadocContentKind.OverviewSummary),
-                    sourceSets = sourceSets.toDisplaySourceSets(),
-                    style = emptySet(),
-                    extra = PropertyContainer.empty()
-                )
-            }
-        )
-    }
-
-    private fun Documentable.authorsToContentNodes(sourceSet: DokkaSourceSet? = highestJvmSourceSet) =
-        allContentNodesFromType<Author>(sourceSet)
-
-    private fun Documentable.sinceToContentNodes(sourceSet: DokkaSourceSet? = highestJvmSourceSet) =
-        allContentNodesFromType<Since>(sourceSet)
-
-    private fun Documentable.returnToContentNodes(sourceSet: DokkaSourceSet? = highestJvmSourceSet) =
-        contentNodesFromType<Return>(sourceSet)
-}
-
diff --git a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPlugin.kt b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPlugin.kt
deleted file mode 100644
index 6a5749ab..00000000
--- a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPlugin.kt
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc
-
-import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.base.renderers.PackageListCreator
-import org.jetbrains.dokka.base.renderers.RootCreator
-import org.jetbrains.dokka.base.resolvers.local.LocationProviderFactory
-import org.jetbrains.dokka.base.resolvers.shared.PackageList.Companion.PACKAGE_LIST_NAME
-import org.jetbrains.dokka.base.resolvers.shared.RecognizedLinkFormat
-import org.jetbrains.dokka.base.signatures.SignatureProvider
-import org.jetbrains.dokka.javadoc.location.JavadocLocationProviderFactory
-import org.jetbrains.dokka.javadoc.pages.*
-import org.jetbrains.dokka.javadoc.renderer.KorteJavadocRenderer
-import org.jetbrains.dokka.javadoc.signatures.JavadocSignatureProvider
-import org.jetbrains.dokka.javadoc.transformers.documentables.JavadocDocumentableJVMSourceSetFilter
-import org.jetbrains.dokka.javadoc.validity.MultiplatformConfiguredChecker
-import org.jetbrains.dokka.kotlinAsJava.KotlinAsJavaPlugin
-import org.jetbrains.dokka.plugability.*
-import org.jetbrains.dokka.renderers.PostAction
-import org.jetbrains.dokka.renderers.Renderer
-import org.jetbrains.dokka.transformers.documentation.DocumentableToPageTranslator
-import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
-import org.jetbrains.dokka.transformers.pages.PageTransformer
-import org.jetbrains.dokka.validity.PreGenerationChecker
-
-public class JavadocPlugin : DokkaPlugin() {
-
-    private val dokkaBasePlugin: DokkaBase by lazy { plugin<DokkaBase>() }
-    private val kotinAsJavaPlugin: KotlinAsJavaPlugin by lazy { plugin<KotlinAsJavaPlugin>() }
-
-    public val locationProviderFactory: ExtensionPoint<LocationProviderFactory> by lazy { dokkaBasePlugin.locationProviderFactory }
-    public val javadocPreprocessors: ExtensionPoint<PageTransformer> by extensionPoint<PageTransformer>()
-
-    public val dokkaJavadocPlugin: Extension<Renderer, *, *> by extending {
-        CoreExtensions.renderer providing { ctx -> KorteJavadocRenderer(ctx, "views") } override dokkaBasePlugin.htmlRenderer
-    }
-
-    public val javadocMultiplatformCheck: Extension<PreGenerationChecker, *, *> by extending {
-        CoreExtensions.preGenerationCheck providing ::MultiplatformConfiguredChecker
-    }
-
-    public val pageTranslator: Extension<DocumentableToPageTranslator, *, *> by extending {
-        CoreExtensions.documentableToPageTranslator providing ::JavadocDocumentableToPageTranslator override
-                kotinAsJavaPlugin.kotlinAsJavaDocumentableToPageTranslator
-    }
-
-    public val documentableSourceSetFilter: Extension<PreMergeDocumentableTransformer, *, *> by extending {
-        dokkaBasePlugin.preMergeDocumentableTransformer providing ::JavadocDocumentableJVMSourceSetFilter
-    }
-
-    public val javadocLocationProviderFactory: Extension<LocationProviderFactory, *, *> by extending {
-        dokkaBasePlugin.locationProviderFactory providing ::JavadocLocationProviderFactory override dokkaBasePlugin.locationProvider
-    }
-
-    public val javadocSignatureProvider: Extension<SignatureProvider, *, *> by extending {
-        dokkaBasePlugin.signatureProvider providing ::JavadocSignatureProvider override kotinAsJavaPlugin.javaSignatureProvider
-    }
-
-    public val rootCreator: Extension<PageTransformer, *, *> by extending {
-        javadocPreprocessors with RootCreator
-    }
-
-    public val packageListCreator: Extension<PageTransformer, *, *> by extending {
-        javadocPreprocessors providing {
-            PackageListCreator(
-                context = it,
-                format = RecognizedLinkFormat.DokkaJavadoc,
-                outputFilesNames = listOf(PACKAGE_LIST_NAME, "element-list")
-            )
-        } order { after(rootCreator) }
-    }
-
-    public val resourcesInstaller: Extension<PageTransformer, *, *> by extending {
-        javadocPreprocessors with ResourcesInstaller order { after(rootCreator) }
-    }
-
-    public val treeViewInstaller: Extension<PageTransformer, *, *> by extending {
-        javadocPreprocessors providing ::TreeViewInstaller order { after(rootCreator) }
-    }
-
-    public val allClassessPageInstaller: Extension<PageTransformer, *, *> by extending {
-        javadocPreprocessors with AllClassesPageInstaller order { before(rootCreator) }
-    }
-
-    public val indexGenerator: Extension<PageTransformer, *, *> by extending {
-        javadocPreprocessors with IndexGenerator order { before(rootCreator) }
-    }
-
-    public val deprecatedPageCreator: Extension<PageTransformer, *, *> by extending {
-        javadocPreprocessors with DeprecatedPageCreator order { before(rootCreator) }
-    }
-
-    internal val alphaVersionNotifier by extending {
-        CoreExtensions.postActions providing { ctx ->
-            PostAction {
-                ctx.logger.info(
-                    "The Javadoc output format is still in Alpha so you may find bugs and experience migration " +
-                            "issues when using it. Successful integration with tools that accept Java's Javadoc " +
-                            "HTML as input is not guaranteed. You use it at your own risk."
-                )
-            }
-        }
-    }
-
-    @OptIn(DokkaPluginApiPreview::class)
-    override fun pluginApiPreviewAcknowledgement(): PluginApiPreviewAcknowledgement =
-        PluginApiPreviewAcknowledgement
-}
-
diff --git a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/location/JavadocLocationProvider.kt b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/location/JavadocLocationProvider.kt
deleted file mode 100644
index 6de4c808..00000000
--- a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/location/JavadocLocationProvider.kt
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package org.jetbrains.dokka.javadoc.location
-
-import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProvider
-import org.jetbrains.dokka.javadoc.pages.*
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.links.Nullable
-import org.jetbrains.dokka.links.PointingToDeclaration
-import org.jetbrains.dokka.model.DisplaySourceSet
-import org.jetbrains.dokka.pages.ContentPage
-import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.pages.RootPageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-import java.util.*
-
-public class JavadocLocationProvider(
-    pageRoot: RootPageNode,
-    dokkaContext: DokkaContext
-) : DefaultLocationProvider(pageRoot, dokkaContext) {
-
-    private val pathIndex = IdentityHashMap<PageNode, List<String>>().apply {
-        fun registerPath(page: PageNode, prefix: List<String> = emptyList()) {
-            val packagePath = page.takeIf { it is JavadocPackagePageNode }?.name.orEmpty()
-                .replace(".", "/")
-            val newPathPrefix = prefix + packagePath
-
-            val path = (prefix + when (page) {
-                is AllClassesPage -&g