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>

1 files changed, 0 insertions, 548 deletions

diff --git a/plugins/kotlin-as-java/src/test/kotlin/CompanionAsJavaTest.kt b/plugins/kotlin-as-java/src/test/kotlin/CompanionAsJavaTest.kt
deleted file mode 100644
index cba5e9ef..00000000
--- a/plugins/kotlin-as-java/src/test/kotlin/CompanionAsJavaTest.kt
+++ /dev/null
@@ -1,548 +0,0 @@
-/*
- * Copyright 2014-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
- */
-
-package kotlinAsJavaPlugin
-
-import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
-import org.jetbrains.dokka.model.*
-import kotlin.test.*
-
-private const val COMPANION_NAME = "C"
-
-class CompanionAsJavaTest : BaseAbstractTest() {
-    private val configuration = dokkaConfiguration {
-        sourceSets {
-            sourceSet {
-                sourceRoots = listOf("src/")
-                classpath += jvmStdlibPath!!
-            }
-        }
-    }
-
-    @Test
-    fun `empty companion object should not be rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {}
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionNotRendered(parentClass)
-            }
-        }
-    }
-
-    @Test
-    fun `companion object with only jvmField should not be rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       @JvmField val jvmFieldProp: String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionNotRendered(parentClass)
-            }
-        }
-    }
-
-    @Test
-    fun `companion property with jvmField should be static`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       @JvmField val jvmFieldProp: String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                val parentClassProperty = parentClass.properties.firstOrNull { it.name == "jvmFieldProp" }
-                assertNotNull(parentClassProperty, "Parent class should contain the companion jvmField property")
-                assertIsStatic(parentClassProperty)
-            }
-        }
-    }
-
-    @Test
-    fun `companion object with only const should not be rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       const val constProp: Int = 0
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionNotRendered(parentClass)
-            }
-        }
-    }
-
-    @Test
-    fun `companion property with const should be static`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       const val constProp: Int = 0
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                val parentClassProperty = parentClass.properties.firstOrNull { it.name == "constProp" }
-                assertNotNull(parentClassProperty, "Parent class should contain the companion const property")
-                assertIsStatic(parentClassProperty)
-            }
-        }
-    }
-
-    @Test
-    fun `companion object with only lateinit not rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       lateinit var lateInitProp: String
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionNotRendered(parentClass)
-            }
-        }
-    }
-
-    @Test
-    fun `companion property with lateinit should be static`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       lateinit var lateInitProp: String
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                val parentClassProperty = parentClass.properties.firstOrNull { it.name == "lateInitProp" }
-                assertNotNull(parentClassProperty, "Parent class should contain the companion lateinit property")
-                assertIsStatic(parentClassProperty)
-            }
-        }
-    }
-
-    @Test
-    fun `companion object with only jvmStatic fun not rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       @JvmStatic fun staticFun(): String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionNotRendered(parentClass)
-            }
-        }
-    }
-
-    @Test
-    fun `companion function with JvmStatic should be static`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       @JvmStatic fun staticFun(): String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                val parentClassFunction = parentClass.functions.firstOrNull { it.name == "staticFun" }
-                assertNotNull(parentClassFunction, "Parent class should contains the companion jvmStatic function")
-                assertIsStatic(parentClassFunction)
-            }
-        }
-    }
-
-    @Test
-    fun `companion object with nested classes is rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       @JvmStatic
-            |       fun staticFun1(): String = ""
-            |       
-            |       const val CONST_VAL: Int = 100
-            |       
-            |       class NestedClass
-            |       object NestedObject
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionRendered(parentClass)
-
-                val classLikes = parentClass.companion?.classlikes
-                assertNotNull(classLikes)
-                assertEquals(2, classLikes.size,
-                    "Classlike list should contains nested class and object")
-                assertTrue(classLikes.any { it.name == "NestedClass" })
-                assertTrue(classLikes.any { it.name == "NestedObject" })
-
-            }
-        }
-    }
-
-    @Test
-    fun `companion object with supertype is rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |
-            |class Parent
-            |interface IParent
-            |class MyClass {
-            |    companion object $COMPANION_NAME : Parent(), IParent {
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionRendered(parentClass)
-            }
-        }
-    }
-
-    @Test
-    fun `companion object rendered for own properties`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       @JvmField
-            |       val jvmField: String = ""
-            |       const val contVal: Int = 0
-            |       lateinit var lateInit: String
-            |       
-            |       val rendered: Int = TODO()
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionRendered(parentClass)
-
-                val properties = parentClass.companion?.properties
-
-                assertNotNull(properties)
-                assertEquals(2, properties.size) // including INSTANCE
-                assertTrue(properties.any { it.name == "rendered" })
-                assertTrue(properties.none { it.name == "jvmField1" })
-                assertTrue(properties.none { it.name == "contVal" })
-                assertTrue(properties.none { it.name == "lateInit" })
-            }
-        }
-    }
-
-    @Test
-    fun `companion object rendered for own functions`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       @JvmStatic
-            |       fun staticFun(): String = ""
-            |       
-            |       fun renderedFun(): String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertCompanionRendered(parentClass)
-
-                val functions = parentClass.companion?.functions
-
-                assertNotNull(functions)
-                assertEquals(1, functions.size)
-                assertTrue(functions.any { it.name == "renderedFun" })
-                assertTrue(functions.none { it.name == "staticFun" })
-            }
-        }
-    }
-
-    @Test
-    fun `companion const value should be rendered as public by default`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       const val constProp: String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertEquals(
-                    JavaVisibility.Public,
-                    parentClass.properties.firstOrNull()?.visibility?.values?.first()
-                )
-                assertNull(parentClass.findFunction("constProp"), "There is no getter for the cont field")
-            }
-        }
-    }
-
-    @Test
-    fun `companion const value should preserve Java modifier`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       protected const val constProp: String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            dokkaConfiguration {
-                sourceSets {
-                    sourceSet {
-                        sourceRoots = listOf("src/")
-                        classpath += jvmStdlibPath!!
-                        documentedVisibilities = setOf(
-                            org.jetbrains.dokka.DokkaConfiguration.Visibility.PUBLIC,
-                            org.jetbrains.dokka.DokkaConfiguration.Visibility.PROTECTED
-                        )
-                    }
-                }
-            },
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertEquals(
-                    JavaVisibility.Protected,
-                    parentClass.properties.firstOrNull()?.visibility?.values?.first()
-                )
-                assertNull(parentClass.findFunction("constProp"), "There is no getter for the cont field")
-            }
-        }
-    }
-
-    @Test
-    fun `companion lateinit value should be rendered as public by default`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       lateinit var lateInitProp: String
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertEquals(
-                    JavaVisibility.Public,
-                    parentClass.properties.firstOrNull()?.visibility?.values?.first()
-                )
-                assertNull(parentClass.findFunction("lateInitProp"), "There is no getter for the cont field")
-            }
-        }
-    }
-
-    @Test
-    fun `named companion instance property should be rendered if companion rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       var property: String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertNotNull(parentClass.properties.any { it.name == COMPANION_NAME })
-            }
-        }
-    }
-
-    @Test
-    fun `default named companion instance property should be rendered if companion rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object {
-            |       var property: String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertTrue(parentClass.properties.any { it.name == "Companion" })
-            }
-        }
-    }
-
-    @Test
-    fun `companion instance property should be hidden if companion not rendered`() {
-        testInline(
-            """
-            |/src/main/kotlin/kotlinAsJavaPlugin/sample.kt
-            |package kotlinAsJavaPlugin
-            |class MyClass {
-            |    companion object $COMPANION_NAME {
-            |       const val property: String = ""
-            |    }
-            |}
-        """.trimMargin(),
-            configuration,
-        ) {
-            documentablesTransformationStage = { module ->
-                val parentClass = module.findClass("MyClass")
-
-                assertTrue(parentClass.properties.none { it.name == COMPANION_NAME })
-            }
-        }
-    }
-}
-
-private fun DModule.findClass(name: String) = packages.flatMap { it.classlikes }
-    .firstOrNull { it.name == name } as DClass
-
-private fun DClass.findFunction(name: String) = functions.firstOrNull { it.name.contains(name, ignoreCase = true) }
-
-private fun assertCompanionRendered(parentClass: DClass) {
-    assertNotNull(parentClass.companion, "Companion should not be null")
-    assertTrue(
-        parentClass.classlikes.any { it.name == COMPANION_NAME },
-        "Companion should be in classlikes list"
-    )
-}
-
-private fun assertCompanionNotRendered(parentClass: DClass) {
-    assertNull(parentClass.companion, "Companion should be null")
-    assertTrue(
-        parentClass.classlikes.none { it.name == COMPANION_NAME },
-        "Companion should not be in classlikes list"
-    )
-}
-
-private fun assertIsStatic(property: DProperty) {
-    val extra = property.extra[AdditionalModifiers]
-    assertNotNull(extra, "extra for property is present")
-    assertTrue(
-        extra.content.values.contains(setOf(ExtraModifiers.JavaOnlyModifiers.Static)),
-        "Property contains extra modifier static"
-    )
-}
-
-private fun assertIsStatic(function: DFunction) {
-    val extra = function.extra[AdditionalModifiers]
-    assertNotNull(extra, "extra for property is present")
-    assertTrue(
-        extra.content.values.contains(setOf(ExtraModifiers.JavaOnlyModifiers.Static)),
-        "Function contains extra modifier static"
-    )
-}