Use Gradle filesystem types for task properties

runners/gradle-plugin/build.gradle.kts

@@ -22,7 +22,7 @@ dependencies {
     testImplementation("com.android.tools.build:gradle:4.0.1")
 
     // Fix https://github.com/gradle/gradle/issues/16774
-    testImplementation (
+    testImplementation(
         files(
             serviceOf<org.gradle.api.internal.classpath.ModuleRegistry>().getModule("gradle-tooling-api-builders")
                 .classpath.asFiles.first()

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,17 @@ 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.getSafe()
+        override fun targetChildOutputDirectory(
+            parent: DokkaMultiModuleTask,
+            child: AbstractDokkaTask
+        ): Provider<Directory> =
+            child.outputDirectory
     }
 
     /**
@@ -34,18 +41,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.getSafe().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 +66,7 @@ internal fun DokkaMultiModuleTask.copyChildOutputDirectories() {
 
 internal fun DokkaMultiModuleTask.copyChildOutputDirectory(child: AbstractDokkaTask) {
     val targetChildOutputDirectory = project.file(fileLayout.get().targetChildOutputDirectory(this, child))
-    val sourceChildOutputDirectory = child.outputDirectory.getSafe()
+    val sourceChildOutputDirectory = child.outputDirectory.get().asFile
 
     /* Pointing to the same directory -> No copy necessary */
     if (sourceChildOutputDirectory.absoluteFile == targetChildOutputDirectory.absoluteFile) {
@@ -79,4 +89,3 @@ internal fun DokkaMultiModuleTask.copyChildOutputDirectory(child: AbstractDokkaT
 
     sourceChildOutputDirectory.copyRecursively(targetChildOutputDirectory, overwrite = true)
 }
-

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 } })
+        }
+    }
 }

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
@@ -18,7 +19,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
 
@@ -55,9 +55,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.safeProperty<File>()
-        .safeConvention(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
@@ -150,10 +149,10 @@ abstract class AbstractDokkaTask : DefaultTask() {
     val failOnWarning: Property<Boolean> = project.objects.safeProperty<Boolean>()
         .safeConvention(DokkaDefaults.failOnWarning)
 
-    @Optional
-    @InputDirectory
-    @PathSensitive(PathSensitivity.RELATIVE)
-    val cacheRoot: Property<File?> = project.objects.safeProperty()
+    @get:Optional
+    @get:InputDirectory
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val cacheRoot: DirectoryProperty
 
     /**
      * Type-safe configuration for a Dokka plugin.

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.getSafe(),
-            outputDir = outputDirectory.getSafe(),
-            cacheRoot = cacheRoot.getSafe(),
+            outputDir = outputDirectory.asFile.get(),
+            cacheRoot = cacheRoot.asFile.orNull,
             failOnWarning = failOnWarning.getSafe(),
             offlineMode = offlineMode.getSafe(),
             pluginsClasspath = plugins.resolve().toList(),

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.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.DokkaModuleDescriptionImpl
@@ -45,23 +47,23 @@ 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.safeProperty<DokkaMultiModuleFileLayout>()
         .safeConvention(DokkaMultiModuleFileLayout.CompactInParent)
 
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    internal val sourceChildOutputDirectories: Iterable<File>
-        get() = childDokkaTasks.map { task -> task.outputDirectory.getSafe() }
+    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>>
@@ -82,23 +84,27 @@ abstract class DokkaMultiModuleTask : AbstractDokkaParentTask() {
         super.generateDocumentation()
     }
 
-    override fun buildDokkaConfiguration(): DokkaConfigurationImpl = DokkaConfigurationImpl(
-        moduleName = moduleName.getSafe(),
-        moduleVersion = moduleVersion.getValidVersionOrNull(),
-        outputDir = outputDirectory.getSafe(),
-        cacheRoot = cacheRoot.getSafe(),
-        pluginsConfiguration = buildPluginsConfiguration(),
-        failOnWarning = failOnWarning.getSafe(),
-        offlineMode = offlineMode.getSafe(),
-        pluginsClasspath = plugins.resolve().toList(),
-        modules = childDokkaTasks.map { dokkaTask ->
-            DokkaModuleDescriptionImpl(
-                name = dokkaTask.moduleName.getSafe(),
-                relativePathToOutputDirectory = targetChildOutputDirectory(dokkaTask).relativeTo(outputDirectory.getSafe()),
-                includes = childDokkaTaskIncludes[dokkaTask.path].orEmpty(),
-                sourceOutputDirectory = dokkaTask.outputDirectory.getSafe()
-            )
-        },
-        includes = includes.toSet(),
-    )
+    override fun buildDokkaConfiguration(): DokkaConfigurationImpl {
+        return DokkaConfigurationImpl(
+            moduleName = moduleName.getSafe(),
+            moduleVersion = moduleVersion.getValidVersionOrNull(),
+            outputDir = outputDirectory.asFile.get(),
+            cacheRoot = cacheRoot.asFile.orNull,
+            pluginsConfiguration = buildPluginsConfiguration(),
+            failOnWarning = failOnWarning.getSafe(),
+            offlineMode = offlineMode.getSafe(),
+            pluginsClasspath = plugins.resolve().toList(),
+            modules = childDokkaTasks.map { dokkaTask ->
+                DokkaModuleDescriptionImpl(
+                    name = dokkaTask.moduleName.getSafe(),
+                    relativePathToOutputDirectory = targetChildOutputDirectory(dokkaTask).get().asFile.relativeTo(
+                        outputDirectory.asFile.get()
+                    ),
+                    includes = childDokkaTaskIncludes[dokkaTask.path].orEmpty(),
+                    sourceOutputDirectory = dokkaTask.outputDirectory.asFile.get(),
+                )
+            },
+            includes = includes.toSet(),
+        )
+    }
 }

runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/tasks/DokkaTask.kt

@@ -2,18 +2,18 @@
 
 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() {
     override fun buildDokkaConfiguration(): DokkaConfigurationImpl =
         DokkaConfigurationImpl(
             moduleName = moduleName.getSafe(),
             moduleVersion = moduleVersion.getValidVersionOrNull(),
-            outputDir = outputDirectory.getSafe(),
-            cacheRoot = cacheRoot.getSafe(),
+            outputDir = outputDirectory.asFile.get(),
+            cacheRoot = cacheRoot.asFile.orNull,
             offlineMode = offlineMode.getSafe(),
             failOnWarning = failOnWarning.getSafe(),
             sourceSets = unsuppressedSourceSets.build(),

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.getSafe(),
             moduleVersion = moduleVersion.orNull,
-            outputDir = outputDirectory.getSafe(),
-            cacheRoot = cacheRoot.getSafe(),
+            outputDir = outputDirectory.asFile.get(),
+            cacheRoot = cacheRoot.asFile.orNull,
             offlineMode = offlineMode.getSafe(),
             failOnWarning = failOnWarning.getSafe(),
             sourceSets = unsuppressedSourceSets.build(),

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")
-
-

runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidAutoConfigurationTest.kt

@@ -78,4 +78,4 @@ class AndroidAutoConfigurationTest {
             assertFailsWith<ResolveException> { sourceSet.classpath.files }
         }
     }
-}
+}