Use Gradle file property types for task inputs & outputs (#2707)

16 files changed, 284 insertions, 107 deletions

diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayout.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayout.kt
index e604ed46..a5c764d0 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayout.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayout.kt
@@ -1,6 +1,10 @@
 package org.jetbrains.dokka.gradle
 
+import org.gradle.api.file.Directory
+import org.gradle.api.provider.Provider
 import org.jetbrains.dokka.DokkaException
+import org.jetbrains.dokka.gradle.DokkaMultiModuleFileLayout.CompactInParent
+import org.jetbrains.dokka.gradle.DokkaMultiModuleFileLayout.NoCopy
 import java.io.File
 
 /**
@@ -16,14 +20,16 @@ fun interface DokkaMultiModuleFileLayout {
      * @return The target output directory of the [child] dokka task referenced by [parent]. This should
      * be unique for all registered child tasks.
      */
-    fun targetChildOutputDirectory(parent: DokkaMultiModuleTask, child: AbstractDokkaTask): File
+    fun targetChildOutputDirectory(parent: DokkaMultiModuleTask, child: AbstractDokkaTask): Provider<Directory>
 
     /**
      * Will link to the original [AbstractDokkaTask.outputDirectory]. This requires no copying of the output files.
      */
     object NoCopy : DokkaMultiModuleFileLayout {
-        override fun targetChildOutputDirectory(parent: DokkaMultiModuleTask, child: AbstractDokkaTask): File =
-            child.outputDirectory.get()
+        override fun targetChildOutputDirectory(
+            parent: DokkaMultiModuleTask,
+            child: AbstractDokkaTask
+        ): Provider<Directory> = child.outputDirectory
     }
 
     /**
@@ -34,18 +40,21 @@ fun interface DokkaMultiModuleFileLayout {
      * {parent output directory}/firstAncestor/secondAncestor
      */
     object CompactInParent : DokkaMultiModuleFileLayout {
-        override fun targetChildOutputDirectory(parent: DokkaMultiModuleTask, child: AbstractDokkaTask): File {
+        override fun targetChildOutputDirectory(
+            parent: DokkaMultiModuleTask,
+            child: AbstractDokkaTask
+        ): Provider<Directory> {
             val relativeProjectPath = parent.project.relativeProjectPath(child.project.path)
             val relativeFilePath = relativeProjectPath.replace(":", File.separator)
             check(!File(relativeFilePath).isAbsolute) { "Unexpected absolute path $relativeFilePath" }
-            return parent.outputDirectory.get().resolve(relativeFilePath)
+            return parent.outputDirectory.dir(relativeFilePath)
         }
     }
 }
 
 internal fun DokkaMultiModuleTask.targetChildOutputDirectory(
     child: AbstractDokkaTask
-): File = fileLayout.get().targetChildOutputDirectory(this, child)
+): Provider<Directory> = fileLayout.get().targetChildOutputDirectory(this, child)
 
 
 internal fun DokkaMultiModuleTask.copyChildOutputDirectories() {
@@ -56,7 +65,7 @@ internal fun DokkaMultiModuleTask.copyChildOutputDirectories() {
 
 internal fun DokkaMultiModuleTask.copyChildOutputDirectory(child: AbstractDokkaTask) {
     val targetChildOutputDirectory = project.file(fileLayout.get().targetChildOutputDirectory(this, child))
-    val sourceChildOutputDirectory = child.outputDirectory.get()
+    val sourceChildOutputDirectory = child.outputDirectory.asFile.get()
 
     /* Pointing to the same directory -> No copy necessary */
     if (sourceChildOutputDirectory.absoluteFile == targetChildOutputDirectory.absoluteFile) {
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaPlugin.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaPlugin.kt
index c6878963..c30fc181 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaPlugin.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaPlugin.kt
@@ -5,7 +5,9 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Dependency
 import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.withType
 import org.gradle.util.GradleVersion
+import org.jetbrains.dokka.DokkaDefaults
 
 open class DokkaPlugin : Plugin<Project> {
     override fun apply(project: Project) {
@@ -25,15 +27,24 @@ open class DokkaPlugin : Plugin<Project> {
             description = "Generates documentation in 'javadoc' format"
         }
 
-        project.setupDokkaTasks("dokkaGfm", allModulesPageAndTemplateProcessing = project.dokkaArtifacts.gfmTemplateProcessing) {
+        project.setupDokkaTasks(
+            "dokkaGfm",
+            allModulesPageAndTemplateProcessing = project.dokkaArtifacts.gfmTemplateProcessing
+        ) {
             plugins.dependencies.add(project.dokkaArtifacts.gfmPlugin)
             description = "Generates documentation in GitHub flavored markdown format"
         }
 
-        project.setupDokkaTasks("dokkaJekyll", allModulesPageAndTemplateProcessing = project.dokkaArtifacts.jekyllTemplateProcessing) {
+        project.setupDokkaTasks(
+            "dokkaJekyll",
+            allModulesPageAndTemplateProcessing = project.dokkaArtifacts.jekyllTemplateProcessing
+        ) {
             plugins.dependencies.add(project.dokkaArtifacts.jekyllPlugin)
             description = "Generates documentation in Jekyll flavored markdown format"
         }
+
+        project.configureEachAbstractDokkaTask()
+        project.configureEachDokkaMultiModuleTask()
     }
 
     /**
@@ -92,4 +103,18 @@ open class DokkaPlugin : Plugin<Project> {
             }
         }
     }
+
+    private fun Project.configureEachAbstractDokkaTask() {
+        tasks.withType<AbstractDokkaTask>().configureEach {
+            val formatClassifier = name.removePrefix("dokka").decapitalize()
+            outputDirectory.convention(project.layout.buildDirectory.dir("dokka/$formatClassifier"))
+            cacheRoot.set(DokkaDefaults.cacheRoot)
+        }
+    }
+
+    private fun Project.configureEachDokkaMultiModuleTask() {
+        tasks.withType<DokkaMultiModuleTask>().configureEach {
+            sourceChildOutputDirectories.from({ childDokkaTasks.map { it.outputDirectory } })
+        }
+    }
 }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/AbstractDokkaTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/AbstractDokkaTask.kt
index b817e51d..d4314e37 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/AbstractDokkaTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/AbstractDokkaTask.kt
@@ -7,6 +7,7 @@ import org.gradle.api.Action
 import org.gradle.api.DefaultTask
 import org.gradle.api.Task
 import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.MapProperty
@@ -19,7 +20,6 @@ import org.gradle.work.DisableCachingByDefault
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.plugability.ConfigurableBlock
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import java.io.File
 import java.util.function.BiConsumer
 import kotlin.reflect.full.createInstance
 
@@ -56,9 +56,8 @@ abstract class AbstractDokkaTask : DefaultTask() {
      * Default is `project/buildDir/taskName.removePrefix("dokka").decapitalize()`, so
      * for `dokkaHtmlMultiModule` task it will be `project/buildDir/htmlMultiModule`
      */
-    @OutputDirectory
-    val outputDirectory: Property<File> = project.objects.property<File>()
-        .convention(project.provider { defaultDokkaOutputDirectory() })
+    @get:OutputDirectory
+    abstract val outputDirectory: DirectoryProperty
 
     /**
      * Configuration for Dokka plugins. This property is not expected to be used directly - if possible, use
@@ -151,10 +150,10 @@ abstract class AbstractDokkaTask : DefaultTask() {
     val failOnWarning: Property<Boolean> = project.objects.property<Boolean>()
         .convention(DokkaDefaults.failOnWarning)
 
-    @Optional
-    @InputDirectory
-    @PathSensitive(PathSensitivity.RELATIVE)
-    val cacheRoot: Property<File?> = project.objects.property()
+    @get:Optional
+    @get:InputDirectory
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val cacheRoot: DirectoryProperty
 
     /**
      * Type-safe configuration for a Dokka plugin.
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaCollectorTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaCollectorTask.kt
index 096dace5..77a84b3f 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaCollectorTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaCollectorTask.kt
@@ -16,8 +16,8 @@ abstract class DokkaCollectorTask : AbstractDokkaParentTask() {
     override fun buildDokkaConfiguration(): DokkaConfigurationImpl {
         val initialDokkaConfiguration = DokkaConfigurationImpl(
             moduleName = moduleName.get(),
-            outputDir = outputDirectory.get(),
-            cacheRoot = cacheRoot.orNull,
+            outputDir = outputDirectory.asFile.get(),
+            cacheRoot = cacheRoot.asFile.orNull,
             failOnWarning = failOnWarning.get(),
             offlineMode = offlineMode.get(),
             pluginsClasspath = plugins.resolve().toList(),
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaMultiModuleTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaMultiModuleTask.kt
index 1b61d57e..0a55f130 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaMultiModuleTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaMultiModuleTask.kt
@@ -3,8 +3,10 @@
 package org.jetbrains.dokka.gradle
 
 import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.Directory
 import org.gradle.api.internal.tasks.TaskDependencyInternal
 import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
 import org.gradle.kotlin.dsl.property
 import org.jetbrains.dokka.DokkaConfigurationImpl
@@ -46,10 +48,10 @@ abstract class DokkaMultiModuleTask : AbstractDokkaParentTask() {
      * Useful stuff in another package.
      * ```
      */
-    @InputFiles
-    @Optional
-    @PathSensitive(PathSensitivity.RELATIVE)
-    val includes: ConfigurableFileCollection = project.files()
+    @get:InputFiles
+    @get:Optional
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val includes: ConfigurableFileCollection
 
     @Internal
     val fileLayout: Property<DokkaMultiModuleFileLayout> = project.objects.property<DokkaMultiModuleFileLayout>()
@@ -57,12 +59,12 @@ abstract class DokkaMultiModuleTask : AbstractDokkaParentTask() {
 
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    internal val sourceChildOutputDirectories: Iterable<File>
-        get() = childDokkaTasks.map { task -> task.outputDirectory.get() }
+    internal abstract val sourceChildOutputDirectories: ConfigurableFileCollection
 
     @get:OutputDirectories
-    internal val targetChildOutputDirectories: Iterable<File>
-        get() = childDokkaTasks.map { task -> targetChildOutputDirectory(task) }
+    internal val targetChildOutputDirectories: Provider<Iterable<Directory>> = project.provider {
+        childDokkaTasks.map { task -> targetChildOutputDirectory(task).get() }
+    }
 
     @get:Input
     internal val childDokkaTaskIncludes: Map<TaskPath, Set<File>>
@@ -83,23 +85,27 @@ abstract class DokkaMultiModuleTask : AbstractDokkaParentTask() {
         super.generateDocumentation()
     }
 
-    override fun buildDokkaConfiguration(): DokkaConfigurationImpl = DokkaConfigurationImpl(
-        moduleName = moduleName.get(),
-        moduleVersion = moduleVersion.getValidVersionOrNull(),
-        outputDir = outputDirectory.get(),
-        cacheRoot = cacheRoot.orNull,
-        pluginsConfiguration = buildPluginsConfiguration(),
+    override fun buildDokkaConfiguration(): DokkaConfigurationImpl {
+        return DokkaConfigurationImpl(
+            moduleName = moduleName.get(),
+            moduleVersion = moduleVersion.getValidVersionOrNull(),
+            outputDir = outputDirectory.asFile.get(),
+            cacheRoot = cacheRoot.asFile.orNull,
+            pluginsConfiguration = buildPluginsConfiguration(),
         failOnWarning = failOnWarning.get(),
         offlineMode = offlineMode.get(),
-        pluginsClasspath = plugins.resolve().toList(),
-        modules = childDokkaTasks.map { dokkaTask ->
-            DokkaModuleDescriptionImpl(
-                name = dokkaTask.moduleName.get(),
-                relativePathToOutputDirectory = targetChildOutputDirectory(dokkaTask).relativeTo(outputDirectory.get()),
-                includes = childDokkaTaskIncludes[dokkaTask.path].orEmpty(),
-                sourceOutputDirectory = dokkaTask.outputDirectory.get()
-            )
-        },
-        includes = includes.toSet(),
-    )
+            pluginsClasspath = plugins.resolve().toList(),
+            modules = childDokkaTasks.map { dokkaTask ->
+                DokkaModuleDescriptionImpl(
+                    name = dokkaTask.moduleName.get(),
+                    relativePathToOutputDirectory = targetChildOutputDirectory(dokkaTask).get().asFile.relativeTo(
+                        outputDirectory.asFile.get()
+                    ),
+                    includes = childDokkaTaskIncludes[dokkaTask.path].orEmpty(),
+                    sourceOutputDirectory = dokkaTask.outputDirectory.asFile.get(),
+                )
+            },
+            includes = includes.toSet(),
+        )
+    }
 }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTask.kt
index 46c59e95..8c6a3767 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTask.kt
@@ -2,9 +2,9 @@
 
 package org.jetbrains.dokka.gradle
 
+import org.gradle.api.tasks.*
 import org.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.build
-import org.gradle.api.tasks.*
 
 @CacheableTask
 abstract class DokkaTask : AbstractDokkaLeafTask() {
@@ -12,8 +12,8 @@ abstract class DokkaTask : AbstractDokkaLeafTask() {
         DokkaConfigurationImpl(
             moduleName = moduleName.get(),
             moduleVersion = moduleVersion.getValidVersionOrNull(),
-            outputDir = outputDirectory.get(),
-            cacheRoot = cacheRoot.orNull,
+            outputDir = outputDirectory.asFile.get(),
+            cacheRoot = cacheRoot.asFile.orNull,
             offlineMode = offlineMode.get(),
             failOnWarning = failOnWarning.get(),
             sourceSets = unsuppressedSourceSets.build(),
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTaskPartial.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTaskPartial.kt
index 8431f1df..1b9f2641 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTaskPartial.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTaskPartial.kt
@@ -2,9 +2,9 @@
 
 package org.jetbrains.dokka.gradle
 
+import org.gradle.api.tasks.*
 import org.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.build
-import org.gradle.api.tasks.*
 
 @CacheableTask
 abstract class DokkaTaskPartial : AbstractDokkaLeafTask() {
@@ -13,8 +13,8 @@ abstract class DokkaTaskPartial : AbstractDokkaLeafTask() {
         return DokkaConfigurationImpl(
             moduleName = moduleName.get(),
             moduleVersion = moduleVersion.orNull,
-            outputDir = outputDirectory.get(),
-            cacheRoot = cacheRoot.orNull,
+            outputDir = outputDirectory.asFile.get(),
+            cacheRoot = cacheRoot.asFile.orNull,
             offlineMode = offlineMode.get(),
             failOnWarning = failOnWarning.get(),
             sourceSets = unsuppressedSourceSets.build(),
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTaskTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTaskTest.kt
index 2cac940f..c5ea42a5 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTaskTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AbstractDokkaParentTaskTest.kt
@@ -7,6 +7,7 @@ import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.getByName
 import org.gradle.testfixtures.ProjectBuilder
 import org.jetbrains.dokka.DokkaConfigurationImpl
+import org.jetbrains.dokka.gradle.utils.subprojects_
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
@@ -19,7 +20,7 @@ class AbstractDokkaParentTaskTest {
     private val subSubproject0 = ProjectBuilder.builder().withName("subSubproject0").withParent(subproject0).build()
 
     init {
-        rootProject.subprojects {
+        rootProject.subprojects_ {
             tasks.create<DokkaTask>("dokkaTask")
         }
     }
@@ -190,12 +191,10 @@ class AbstractDokkaParentTaskTest {
     }
 }
 
-internal open class TestDokkaParentTask : AbstractDokkaParentTask() {
+internal abstract class TestDokkaParentTask : AbstractDokkaParentTask() {
     override fun buildDokkaConfiguration(): DokkaConfigurationImpl {
         throw NotImplementedError()
     }
 }
 
 private val Project.dokkaTask: DokkaTask get() = tasks.getByName<DokkaTask>("dokkaTask")
-
-
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationJsonTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationJsonTest.kt
index 108c7fe0..d01847a0 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationJsonTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationJsonTest.kt
@@ -2,7 +2,13 @@ package org.jetbrains.dokka.gradle
 
 import org.gradle.kotlin.dsl.withType
 import org.gradle.testfixtures.ProjectBuilder
-import org.jetbrains.dokka.*
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaConfigurationImpl
+import org.jetbrains.dokka.PluginConfigurationImpl
+import org.jetbrains.dokka.gradle.utils.create_
+import org.jetbrains.dokka.gradle.utils.externalDocumentationLink_
+import org.jetbrains.dokka.gradle.utils.withDependencies_
+import org.jetbrains.dokka.toCompactJsonString
 import java.io.File
 import java.net.URL
 import kotlin.test.Test
@@ -15,23 +21,31 @@ class DokkaConfigurationJsonTest {
         val project = ProjectBuilder.builder().build()
         project.plugins.apply("org.jetbrains.dokka")
         val dokkaTask = project.tasks.withType<DokkaTask>().first()
-        dokkaTask.plugins.withDependencies { clear() }
+        dokkaTask.plugins.withDependencies_ { clear() }
         dokkaTask.apply {
             this.failOnWarning.set(true)
             this.offlineMode.set(true)
             this.outputDirectory.set(File("customOutputDir"))
             this.cacheRoot.set(File("customCacheRoot"))
             this.pluginsConfiguration.add(
-                PluginConfigurationImpl("A", DokkaConfiguration.SerializationFormat.JSON, """ { "key" : "value1" } """)
+                PluginConfigurationImpl(
+                    "A",
+                    DokkaConfiguration.SerializationFormat.JSON,
+                    """ { "key" : "value1" } """
+                )
             )
             this.pluginsConfiguration.add(
-                PluginConfigurationImpl("B", DokkaConfiguration.SerializationFormat.JSON, """ { "key" : "value2" } """)
+                PluginConfigurationImpl(
+                    "B",
+                    DokkaConfiguration.SerializationFormat.JSON,
+                    """ { "key" : "value2" } """
+                )
             )
-            this.dokkaSourceSets.create("main") {
+            this.dokkaSourceSets.create_("main") {
                 displayName.set("customSourceSetDisplayName")
                 reportUndocumented.set(true)
 
-                externalDocumentationLink {
+                externalDocumentationLink_ {
                     packageListUrl.set(URL("http://some.url"))
                     url.set(URL("http://some.other.url"))
                 }
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationSerializableTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationSerializableTest.kt
index 75e2b63e..b5230114 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationSerializableTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaConfigurationSerializableTest.kt
@@ -4,6 +4,9 @@ import org.gradle.kotlin.dsl.withType
 import org.gradle.testfixtures.ProjectBuilder
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.PluginConfigurationImpl
+import org.jetbrains.dokka.gradle.utils.create_
+import org.jetbrains.dokka.gradle.utils.externalDocumentationLink_
+import org.jetbrains.dokka.gradle.utils.withDependencies_
 import org.junit.Rule
 import org.junit.rules.TemporaryFolder
 import java.io.File
@@ -24,19 +27,31 @@ class DokkaConfigurationSerializableTest {
         val project = ProjectBuilder.builder().build()
         project.plugins.apply("org.jetbrains.dokka")
         val dokkaTask = project.tasks.withType<DokkaTask>().first()
-        dokkaTask.plugins.withDependencies { clear() }
+        dokkaTask.plugins.withDependencies_ { clear() }
         dokkaTask.apply {
             this.failOnWarning.set(true)
             this.offlineMode.set(true)
             this.outputDirectory.set(File("customOutputDir"))
             this.cacheRoot.set(File("customCacheRoot"))
-            this.pluginsConfiguration.add(PluginConfigurationImpl("A", DokkaConfiguration.SerializationFormat.JSON, """ { "key" : "value1" } """))
-            this.pluginsConfiguration.add(PluginConfigurationImpl("B", DokkaConfiguration.SerializationFormat.JSON, """ { "key" : "value2" } """))
-            this.dokkaSourceSets.create("main") {
+            this.pluginsConfiguration.add(
+                PluginConfigurationImpl(
+                    "A",
+                    DokkaConfiguration.SerializationFormat.JSON,
+                    """ { "key" : "value1" } """
+                )
+            )
+            this.pluginsConfiguration.add(
+                PluginConfigurationImpl(
+                    "B",
+                    DokkaConfiguration.SerializationFormat.JSON,
+                    """ { "key" : "value2" } """
+                )
+            )
+            this.dokkaSourceSets.create_("main") {
                 displayName.set("customSourceSetDisplayName")
                 reportUndocumented.set(true)
 
-                externalDocumentationLink {
+                externalDocumentationLink_ {
                     packageListUrl.set(URL("http://some.url"))
                     url.set(URL("http://some.other.url"))
                 }
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayoutTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayoutTest.kt
index d00664b5..6f0ce8a2 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayoutTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleFileLayoutTest.kt
@@ -16,12 +16,15 @@ class DokkaMultiModuleFileLayoutTest {
     @Test
     fun `no copy`() {
         val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
         val child = project.tasks.create<DokkaTask>("child")
         val parent = project.tasks.create<DokkaMultiModuleTask>("parent")
         child.outputDirectory.set(File("some/path"))
 
         assertEquals(
-            File("some/path"), NoCopy.targetChildOutputDirectory(parent, child),
+            File("some/path"),
+            NoCopy.targetChildOutputDirectory(parent, child).get().asFile.relativeTo(project.projectDir),
             "Expected original file path returned"
         )
     }
@@ -29,16 +32,21 @@ class DokkaMultiModuleFileLayoutTest {
     @Test
     fun `compact in parent`() {
         val rootProject = ProjectBuilder.builder().build()
+
         val parentProject = ProjectBuilder.builder().withName("parent").withParent(rootProject).build()
+        parentProject.plugins.apply("org.jetbrains.dokka")
+
         val intermediateProject = ProjectBuilder.builder().withName("intermediate").withParent(parentProject).build()
         val childProject = ProjectBuilder.builder().withName("child").withParent(intermediateProject).build()
+        childProject.plugins.apply("org.jetbrains.dokka")
 
         val parentTask = parentProject.tasks.create<DokkaMultiModuleTask>("parentTask")
         val childTask = childProject.tasks.create<DokkaTask>("childTask")
 
         val targetOutputDirectory = CompactInParent.targetChildOutputDirectory(parentTask, childTask)
         assertEquals(
-            parentTask.outputDirectory.get().resolve("intermediate/child"), targetOutputDirectory,
+            parentTask.outputDirectory.get().asFile.resolve("intermediate/child"),
+            targetOutputDirectory.get().asFile,
             "Expected nested file structure representing project structure"
         )
     }
@@ -47,17 +55,21 @@ class DokkaMultiModuleFileLayoutTest {
     fun copyChildOutputDirectory() {
         /* Prepare */
         val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
         val childTask = project.tasks.create<DokkaTask>("child")
         val parentTask = project.tasks.create<DokkaMultiModuleTask>("parent")
 
-        val sourceOutputDirectory = childTask.outputDirectory.get()
+        val sourceOutputDirectory = childTask.outputDirectory.get().asFile
         sourceOutputDirectory.mkdirs()
         sourceOutputDirectory.resolve("some.file").writeText("some text")
         val subFolder = sourceOutputDirectory.resolve("subFolder")
         subFolder.mkdirs()
         subFolder.resolve("other.file").writeText("other text")
 
-        parentTask.fileLayout.set(DokkaMultiModuleFileLayout { parent, _ -> parent.project.file("target/output") })
+        parentTask.fileLayout.set(DokkaMultiModuleFileLayout { parent, _ ->
+            parent.project.provider { parent.project.layout.projectDirectory.dir("target/output") }
+        })
         parentTask.copyChildOutputDirectory(childTask)
 
         /* Assertions */
@@ -99,10 +111,12 @@ class DokkaMultiModuleFileLayoutTest {
     @Test
     fun `copyChildOutputDirectory target output directory within itself throws DokkaException`() {
         val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
         val childTask = project.tasks.create<DokkaTask>("child")
         val parentTask = project.tasks.create<DokkaMultiModuleTask>("parent")
         parentTask.fileLayout.set(DokkaMultiModuleFileLayout { _, child ->
-            child.outputDirectory.get().resolve("subfolder")
+            child.outputDirectory.dir("subfolder")
         })
         assertFailsWith<DokkaException> { parentTask.copyChildOutputDirectory(childTask) }
     }
@@ -110,6 +124,8 @@ class DokkaMultiModuleFileLayoutTest {
     @Test
     fun `copyChildOutputDirectory NoCopy`() {
         val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
         val childTask = project.tasks.create<DokkaTask>("child")
         val parentTask = project.tasks.create<DokkaMultiModuleTask>("parent")
         parentTask.fileLayout.set(NoCopy)
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
index 52485cdc..fe6869e9 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
@@ -2,7 +2,8 @@ package org.jetbrains.dokka.gradle
 
 import org.gradle.kotlin.dsl.withType
 import org.gradle.testfixtures.ProjectBuilder
-import org.jetbrains.dokka.DokkaSourceSetID
+import org.jetbrains.dokka.gradle.utils.configureEach_
+import org.jetbrains.dokka.gradle.utils.create_
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 import java.io.File
 import kotlin.test.Test
@@ -13,12 +14,12 @@ class KotlinDslDokkaTaskConfigurationTest {
     fun `configure dokka task`() {
         val project = ProjectBuilder.builder().build()
         project.plugins.apply("org.jetbrains.dokka")
-        project.tasks.withType<DokkaTask>().configureEach {
+        project.tasks.withType<DokkaTask>().configureEach_ {
             outputDirectory.set(File("test"))
         }
 
         project.tasks.withType(DokkaTask::class.java).forEach { dokkaTask ->
-            assertEquals(File("test"), dokkaTask.outputDirectory.get())
+            assertEquals(File("test"), dokkaTask.outputDirectory.get().asFile.relativeTo(project.projectDir))
         }
     }
 
@@ -30,7 +31,7 @@ class KotlinDslDokkaTaskConfigurationTest {
         project.tasks.withType(DokkaTask::class.java).forEach { dokkaTask ->
             dokkaTask.dokkaSourceSets.run {
                 val commonMain = create("commonMain")
-                val jvmMain = create("jvmMain") {
+                val jvmMain = create_("jvmMain") {
                     dependsOn("commonMain")
                 }
 
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTaskTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaCollectorTaskTest.kt
index b9c20dce..3c7b58a0 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTaskTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaCollectorTaskTest.kt
@@ -1,10 +1,17 @@
-package org.jetbrains.dokka.gradle
+package org.jetbrains.dokka.gradle.tasks
 
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.withType
 import org.gradle.testfixtures.ProjectBuilder
 import org.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.DokkaException
+import org.jetbrains.dokka.gradle.AbstractDokkaTask
+import org.jetbrains.dokka.gradle.DokkaCollectorTask
+import org.jetbrains.dokka.gradle.DokkaTask
+import org.jetbrains.dokka.gradle.utils.all_
+import org.jetbrains.dokka.gradle.utils.allprojects_
+import org.jetbrains.dokka.gradle.utils.configureEach_
+import org.jetbrains.dokka.gradle.utils.withDependencies_
 import java.io.File
 import kotlin.test.*
 
@@ -16,20 +23,20 @@ class DokkaCollectorTaskTest {
         val childProject = ProjectBuilder.builder().withParent(rootProject).build()
         childProject.plugins.apply("org.jetbrains.kotlin.jvm")
 
-        rootProject.allprojects {
+        rootProject.allprojects_ {
             plugins.apply("org.jetbrains.dokka")
-            tasks.withType<AbstractDokkaTask>().configureEach {
-                plugins.withDependencies { clear() }
+            tasks.withType<AbstractDokkaTask>().configureEach_ {
+                plugins.withDependencies_ { clear() }
             }
-            tasks.withType<DokkaTask>().configureEach {
-                dokkaSourceSets.configureEach {
+            tasks.withType<DokkaTask>().configureEach_ {
+                dokkaSourceSets.configureEach_ {
                     classpath.setFrom(emptyList<Any>())
                 }
             }
         }
 
         val collectorTasks = rootProject.tasks.withType<DokkaCollectorTask>()
-        collectorTasks.configureEach {
+        collectorTasks.configureEach_ {
             moduleName.set("custom Module Name")
             outputDirectory.set(File("customOutputDirectory"))
             cacheRoot.set(File("customCacheRoot"))
@@ -44,8 +51,8 @@ class DokkaCollectorTaskTest {
             assertEquals(
                 DokkaConfigurationImpl(
                     moduleName = "custom Module Name",
-                    outputDir = File("customOutputDirectory"),
-                    cacheRoot = File("customCacheRoot"),
+                    outputDir = rootProject.projectDir.resolve("customOutputDirectory"),
+                    cacheRoot = rootProject.projectDir.resolve("customCacheRoot"),
                     failOnWarning = true,
                     offlineMode = true,
                     sourceSets = task.childDokkaTasks
@@ -67,20 +74,20 @@ class DokkaCollectorTaskTest {
         val childProject = ProjectBuilder.builder().withParent(rootProject).build()
         childProject.plugins.apply("org.jetbrains.kotlin.jvm")
 
-        rootProject.allprojects {
+        rootProject.allprojects_ {
             plugins.apply("org.jetbrains.dokka")
-            tasks.withType<AbstractDokkaTask>().configureEach {
-                plugins.withDependencies { clear() }
+            tasks.withType<AbstractDokkaTask>().configureEach_ {
+                plugins.withDependencies_ { clear() }
             }
-            tasks.withType<DokkaTask>().configureEach {
-                dokkaSourceSets.configureEach {
+            tasks.withType<DokkaTask>().configureEach_ {
+                dokkaSourceSets.configureEach_ {
                     classpath.setFrom(emptyList<Any>())
                 }
             }
         }
 
         val collectorTasks = rootProject.tasks.withType<DokkaCollectorTask>()
-        collectorTasks.configureEach {
+        collectorTasks.configureEach_ {
             cacheRoot.set(null as File?)
         }
 
@@ -96,7 +103,7 @@ class DokkaCollectorTaskTest {
     fun `with no child tasks throws DokkaException`() {
         val project = ProjectBuilder.builder().build()
         val collectorTask = project.tasks.create<DokkaCollectorTask>("collector")
-        project.configurations.all { withDependencies { clear() } }
+        project.configurations.all_ { withDependencies_ { clear() } }
         assertFailsWith<DokkaException> { collectorTask.generateDocumentation() }
     }
 }
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaMultiModuleTaskTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaMultiModuleTaskTest.kt
index ecbe3355..6df809ff 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaMultiModuleTaskTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaMultiModuleTaskTest.kt
@@ -6,6 +6,10 @@ import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.withType
 import org.gradle.testfixtures.ProjectBuilder
 import org.jetbrains.dokka.*
+import org.jetbrains.dokka.gradle.utils.allprojects_
+import org.jetbrains.dokka.gradle.utils.configureEach_
+import org.jetbrains.dokka.gradle.utils.create_
+import org.jetbrains.dokka.gradle.utils.withDependencies_
 import java.io.File
 import kotlin.test.*
 
@@ -27,9 +31,11 @@ class DokkaMultiModuleTaskTest {
     }
 
     init {
-        rootProject.allprojects {
-            tasks.withType<AbstractDokkaTask>().configureEach {
-                plugins.withDependencies { clear() }
+        rootProject.plugins.apply("org.jetbrains.dokka")
+        childProject.plugins.apply("org.jetbrains.dokka")
+        rootProject.allprojects_ {
+            tasks.withType<AbstractDokkaTask>().configureEach_ {
+                plugins.withDependencies_ { clear() }
             }
         }
     }
@@ -56,7 +62,7 @@ class DokkaMultiModuleTaskTest {
         childDokkaTask.apply {
             dokkaSourceSets.create("main")
             dokkaSourceSets.create("test")
-            dokkaSourceSets.configureEach {
+            dokkaSourceSets.configureEach_ {
                 includes.from(include1, include2)
             }
         }
@@ -84,7 +90,7 @@ class DokkaMultiModuleTaskTest {
                 moduleName = "custom Module Name",
                 moduleVersion = "1.5.0",
                 outputDir = multiModuleTask.project.buildDir.resolve("customOutputDirectory"),
-                cacheRoot = File("customCacheRoot"),
+                cacheRoot = multiModuleTask.project.projectDir.resolve("customCacheRoot"),
                 pluginsConfiguration = mutableListOf(
                     PluginConfigurationImpl(
                         "pluginA",
@@ -101,7 +107,7 @@ class DokkaMultiModuleTaskTest {
                         name = "child",
                         relativePathToOutputDirectory = File("child"),
                         includes = setOf(include1, include2),
-                        sourceOutputDirectory = childDokkaTask.outputDirectory.get()
+                        sourceOutputDirectory = childDokkaTask.outputDirectory.get().asFile
                     )
                 )
             ),
@@ -151,7 +157,7 @@ class DokkaMultiModuleTaskTest {
     fun `multimodule task with no child tasks throws DokkaException`() {
         val project = ProjectBuilder.builder().build()
         val multimodule = project.tasks.create<DokkaMultiModuleTask>("multimodule")
-        project.configurations.configureEach { withDependencies { clear() } }
+        project.configurations.configureEach_ { withDependencies_ { clear() } }
         assertFailsWith<DokkaException> { multimodule.generateDocumentation() }
     }
 
@@ -162,17 +168,17 @@ class DokkaMultiModuleTaskTest {
         val childDokkaTaskInclude3 = childProject.file("include3")
 
         childDokkaTask.apply {
-            dokkaSourceSets.create("main") {
+            dokkaSourceSets.create_("main") {
                 includes.from(childDokkaTaskInclude1, childDokkaTaskInclude2)
             }
-            dokkaSourceSets.create("main2") {
+            dokkaSourceSets.create_("main2") {
                 includes.from(childDokkaTaskInclude3)
             }
         }
 
         val secondChildDokkaTaskInclude = childProject.file("include4")
         val secondChildDokkaTask = childProject.tasks.create<DokkaTaskPartial>("secondChildDokkaTask") {
-            dokkaSourceSets.create("main") {
+            dokkaSourceSets.create_("main") {
                 includes.from(secondChildDokkaTaskInclude)
             }
         }
@@ -194,7 +200,9 @@ class DokkaMultiModuleTaskTest {
     @Test
     fun sourceChildOutputDirectories() {
         val parent = ProjectBuilder.builder().build()
+        parent.plugins.apply("org.jetbrains.dokka")
         val child = ProjectBuilder.builder().withName("child").withParent(parent).build()
+        child.plugins.apply("org.jetbrains.dokka")
 
         val parentTask = parent.tasks.create<DokkaMultiModuleTask>("parent")
         val childTask = child.tasks.create<DokkaTask>("child")
@@ -203,7 +211,8 @@ class DokkaMultiModuleTaskTest {
         childTask.outputDirectory.set(child.file("custom/output"))
 
         assertEquals(
-            listOf(parent.file("child/custom/output")), parentTask.sourceChildOutputDirectories,
+            listOf(parent.file("child/custom/output")),
+            parentTask.sourceChildOutputDirectories.files.toList(),
             "Expected child output directory being present"
         )
     }
@@ -219,11 +228,12 @@ class DokkaMultiModuleTaskTest {
         parentTask.addChildTask(childTask)
 
         parentTask.fileLayout.set(DokkaMultiModuleFileLayout { taskParent, taskChild ->
-            taskParent.project.buildDir.resolve(taskChild.name)
+            taskParent.project.layout.buildDirectory.dir(taskChild.name)
         })
 
         assertEquals(
-            listOf(parent.project.buildDir.resolve("child")), parentTask.targetChildOutputDirectories,
+            listOf(parent.project.buildDir.resolve("child")),
+            parentTask.targetChildOutputDirectories.get().map { it.asFile },
             "Expected child target output directory being present"
         )
     }
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTaskTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTaskTest.kt
index 518a01f1..79b80fa3 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTaskTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTaskTest.kt
@@ -4,6 +4,9 @@ package org.jetbrains.dokka.gradle
 
 import org.gradle.kotlin.dsl.create
 import org.gradle.testfixtures.ProjectBuilder
+import org.jetbrains.dokka.gradle.utils.all_
+import org.jetbrains.dokka.gradle.utils.register_
+import org.jetbrains.dokka.gradle.utils.withDependencies_
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNull
@@ -12,12 +15,14 @@ class DokkaTaskTest {
     @Test
     fun `no suppressed source sets are present after in built configuration`() {
         val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
         val task = project.tasks.create<DokkaTask>("dokkaTask")
-        project.configurations.all { withDependencies { clear() } }
+        project.configurations.all_ { withDependencies_ { clear() } }
 
         task.dokkaSourceSets.register("main")
         task.dokkaSourceSets.register("jvm")
-        task.dokkaSourceSets.register("test") {
+        task.dokkaSourceSets.register_("test") {
             suppress.set(true)
         }
 
@@ -29,10 +34,12 @@ class DokkaTaskTest {
     }
 
     @Test
-    fun `module version is not present if not specified`(){
+    fun `module version is not present if not specified`() {
         val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
         val task = project.tasks.create<DokkaTask>("dokkaTask")
-        project.configurations.all { withDependencies { clear() } }
+        project.configurations.all_ { withDependencies_ { clear() } }
 
         task.dokkaSourceSets.register("main")
         assertNull(task.buildDokkaConfiguration().moduleVersion)
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/utils/samWithReceiverWorkarounds.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/utils/samWithReceiverWorkarounds.kt
new file mode 100644
index 00000000..4738f7d8
--- /dev/null
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/utils/samWithReceiverWorkarounds.kt
@@ -0,0 +1,69 @@
+package org.jetbrains.dokka.gradle.utils
+
+import org.gradle.api.*
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.DependencySet
+import org.jetbrains.dokka.gradle.GradleDokkaSourceSetBuilder
+import org.jetbrains.dokka.gradle.GradleExternalDocumentationLinkBuilder
+
+
+/**
+ * Workarounds because `SamWithReceiver` not working in test sources
+ * https://youtrack.jetbrains.com/issue/KTIJ-14684
+ *
+ * The `SamWithReceiver` plugin is automatically applied by the `kotlin-dsl` plugin.
+ * It converts all [org.gradle.api.Action] so the parameter is the receiver:
+ *
+ * ```
+ * // with SamWithReceiver ✅
+ * tasks.configureEach {
+ *   val task: Task = this
+ * }
+ *
+ * // without SamWithReceiver
+ * tasks.configureEach { it ->
+ *   val task: Task = it
+ * }
+ * ```
+ *
+ * This is nice because it means that the Dokka Gradle Plugin more closely matches `build.gradle.kts` files.
+ *
+ * However, [IntelliJ is bugged](https://youtrack.jetbrains.com/issue/KTIJ-14684) and doesn't
+ * acknowledge that `SamWithReceiver` has been applied in test sources. The code works and compiles,
+ * but IntelliJ shows red errors.
+ *
+ * These functions are workarounds, and should be removed ASAP.
+ */
+@Suppress("unused")
+private object Explain
+
+fun Project.subprojects_(configure: Project.() -> Unit) =
+    subprojects(configure)
+
+@Suppress("SpellCheckingInspection")
+fun Project.allprojects_(configure: Project.() -> Unit) =
+    allprojects(configure)
+
+fun <T> DomainObjectCollection<T>.configureEach_(configure: T.() -> Unit) =
+    configureEach(configure)
+
+fun <T> DomainObjectCollection<T>.all_(configure: T.() -> Unit) =
+    all(configure)
+
+fun Configuration.withDependencies_(action: DependencySet.() -> Unit): Configuration =
+    withDependencies(action)
+
+
+fun <T> NamedDomainObjectContainer<T>.create_(name: String, configure: T.() -> Unit): T =
+    create(name, configure)
+
+fun <T> NamedDomainObjectContainer<T>.register_(
+    name: String,
+    configure: T.() -> Unit
+): NamedDomainObjectProvider<T> =
+    register(name, configure)
+
+
+fun GradleDokkaSourceSetBuilder.externalDocumentationLink_(
+    action: GradleExternalDocumentationLinkBuilder.() -> Unit
+) = externalDocumentationLink(action)