Use Gradle's new Property/Provider APIs

31 files changed, 475 insertions, 315 deletions

diff --git a/.run/it-android-0_dokka.run.xml b/.run/it-android-0_dokka.run.xml
index 305ad77e..514177ed 100644
--- a/.run/it-android-0_dokka.run.xml
+++ b/.run/it-android-0_dokka.run.xml
@@ -1,10 +1,10 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="it-android-0:dokka" type="GradleRunConfiguration" factoryName="Gradle" folderName="sample-projects">
+  <configuration default="false" name="it-android-0:dokkaHtml" type="GradleRunConfiguration" factoryName="Gradle" folderName="sample-projects">
     <ExternalSystemSettings>
       <option name="executionName" />
       <option name="externalProjectPath" value="$PROJECT_DIR$/integration-tests/gradle/projects/it-android-0" />
       <option name="externalSystemIdString" value="GRADLE" />
-      <option name="scriptParameters" value="" />
+      <option name="scriptParameters" value="--stacktrace -i" />
       <option name="taskDescriptions">
         <list />
       </option>
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index b26b93a4..35c0f02e 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -16,7 +16,6 @@ object DokkaDefaults {
     const val failOnWarning: Boolean = false
 
     const val includeNonPublic: Boolean = false
-    const val includeRootPackage: Boolean = false
     const val reportUndocumented: Boolean = false
     const val skipEmptyPackages: Boolean = true
     const val skipDeprecated: Boolean = false
@@ -92,7 +91,6 @@ interface DokkaConfiguration : Serializable {
         val samples: Set<File>
         val includes: Set<File>
         val includeNonPublic: Boolean
-        val includeRootPackage: Boolean
         val reportUndocumented: Boolean
         val skipEmptyPackages: Boolean
         val skipDeprecated: Boolean
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index 1b79ec61..384fa27e 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -26,7 +26,6 @@ data class DokkaSourceSetImpl(
     override val samples: Set<File> = emptySet(),
     override val includes: Set<File> = emptySet(),
     override val includeNonPublic: Boolean = DokkaDefaults.includeNonPublic,
-    override val includeRootPackage: Boolean = DokkaDefaults.includeRootPackage,
     override val reportUndocumented: Boolean = DokkaDefaults.reportUndocumented,
     override val skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages,
     override val skipDeprecated: Boolean = DokkaDefaults.skipDeprecated,
diff --git a/integration-tests/gradle/projects/it-basic-groovy/build.gradle b/integration-tests/gradle/projects/it-basic-groovy/build.gradle
index fadf4287..5c6104d5 100644
--- a/integration-tests/gradle/projects/it-basic-groovy/build.gradle
+++ b/integration-tests/gradle/projects/it-basic-groovy/build.gradle
@@ -17,8 +17,10 @@ dokkaHtml {
         customSourceSet {
             sourceRoot(file("src/main/java"))
             sourceRoot(file("src/main/kotlin"))
-            displayName = "custom"
-            reportUndocumented = true
+
+            // TODO NOW: Can we get rid of this .set here?
+            displayName.set("custom")
+            reportUndocumented.set(true)
         }
     }
 
diff --git a/integration-tests/gradle/projects/it-basic/build.gradle.kts b/integration-tests/gradle/projects/it-basic/build.gradle.kts
index 45454e29..1840ba94 100644
--- a/integration-tests/gradle/projects/it-basic/build.gradle.kts
+++ b/integration-tests/gradle/projects/it-basic/build.gradle.kts
@@ -9,6 +9,7 @@ apply(from = "../template.root.gradle.kts")
 
 dependencies {
     implementation(kotlin("stdlib"))
+    testImplementation(kotlin("test-junit"))
 }
 
 tasks.withType<DokkaTask> {
@@ -21,5 +22,11 @@ tasks.withType<DokkaTask> {
                 suppress.set(true)
             }
         }
+
+        register("myTest") {
+            kotlinSourceSet(kotlin.sourceSets["test"])
+        }
     }
 }
+
+buildDir.resolve("")
diff --git a/integration-tests/gradle/projects/it-basic/src/test/kotlin/it/basic/TestClass.kt b/integration-tests/gradle/projects/it-basic/src/test/kotlin/it/basic/TestClass.kt
new file mode 100644
index 00000000..3584bdef
--- /dev/null
+++ b/integration-tests/gradle/projects/it-basic/src/test/kotlin/it/basic/TestClass.kt
@@ -0,0 +1,17 @@
+package it.basic
+
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+annotation class OurAnnotation
+
+class TestClass {
+    /**
+     * Asserts something. [PublicClass]
+     */
+    @Test
+    @OurAnnotation
+    fun test() {
+        assertTrue(1 == 1)
+    }
+}
diff --git a/plugins/base/test-utils/src/main/kotlin/renderers/defaultSourceSet.kt b/plugins/base/test-utils/src/main/kotlin/renderers/defaultSourceSet.kt
index 8d19870c..20fadc5f 100644
--- a/plugins/base/test-utils/src/main/kotlin/renderers/defaultSourceSet.kt
+++ b/plugins/base/test-utils/src/main/kotlin/renderers/defaultSourceSet.kt
@@ -14,7 +14,6 @@ val defaultSourceSet = DokkaSourceSetImpl(
     samples = emptySet(),
     includes = emptySet(),
     includeNonPublic = false,
-    includeRootPackage = false,
     reportUndocumented = false,
     skipEmptyPackages = true,
     skipDeprecated = false,
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index a9c15ec1..43c46d92 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -159,9 +159,6 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
     val includeNonPublic: Boolean by parser.option(ArgType.Boolean, description = "Include non public")
         .default(DokkaDefaults.includeNonPublic)
 
-    val includeRootPackage by parser.option(ArgType.Boolean, description = "Include root package")
-        .default(DokkaDefaults.includeRootPackage)
-
     val reportUndocumented by parser.option(ArgType.Boolean, description = "Report undocumented members")
         .default(DokkaDefaults.reportUndocumented)
 
@@ -234,7 +231,6 @@ private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceS
         override val samples = samples.toMutableSet()
         override val includes = includes.toMutableSet()
         override val includeNonPublic = includeNonPublic
-        override val includeRootPackage = includeRootPackage
         override val reportUndocumented = reportUndocumented
         override val skipEmptyPackages = skipEmptyPackages
         override val skipDeprecated = skipDeprecated
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaProperty.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaProperty.kt
new file mode 100644
index 00000000..c24e369c
--- /dev/null
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaProperty.kt
@@ -0,0 +1,21 @@
+package org.jetbrains.dokka.gradle
+
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.kotlin.dsl.property
+import org.jetbrains.dokka.utilities.cast
+import kotlin.reflect.typeOf
+
+internal inline fun <reified T : Any> ObjectFactory.safeProperty() = property<T?>()
+
+internal inline fun <reified T : Any> Property<T?>.safeConvention(value: T): Property<T> {
+    @Suppress("UnstableApiUsage")
+    return this.convention(value).cast()
+}
+
+@OptIn(ExperimentalStdlibApi::class)
+internal inline fun <reified T> Provider<T>.getSafe(): T {
+    return if (typeOf<T>().isMarkedNullable) orNull as T
+    else get()
+}
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
index 06b936ce..c5713d16 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt
@@ -6,6 +6,7 @@ import org.gradle.api.tasks.Nested
 import org.jetbrains.dokka.DokkaBootstrapImpl
 import org.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.build
+import org.jetbrains.dokka.gradle.kotlin.isMainSourceSet
 
 open class DokkaTask : AbstractDokkaTask(DokkaBootstrapImpl::class) {
 
@@ -14,9 +15,11 @@ open class DokkaTask : AbstractDokkaTask(DokkaBootstrapImpl::class) {
         project.container(GradleDokkaSourceSetBuilder::class.java, GradleDokkaSourceSetBuilderFactory())
             .also { container ->
                 DslObject(this).extensions.add("dokkaSourceSets", container)
-                project.findKotlinSourceSets().orEmpty().forEach { kotlinSourceSet ->
-                    container.register(kotlinSourceSet.name) { dokkaSourceSet ->
-                        dokkaSourceSet.configureWithKotlinSourceSetGist(kotlinSourceSet)
+                project.kotlinOrNull?.sourceSets?.all { kotlinSourceSet ->
+                    if (project.isMainSourceSet(kotlinSourceSet)) {
+                        container.register(kotlinSourceSet.name) { dokkaSourceSet ->
+                            dokkaSourceSet.configureWithKotlinSourceSet(kotlinSourceSet)
+                        }
                     }
                 }
             }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilder.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilder.kt
index 09c9bec9..8f0a166b 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilder.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilder.kt
@@ -1,14 +1,20 @@
-@file:Suppress("FunctionName")
+@file:Suppress("FunctionName", "UnstableApiUsage")
 
 package org.jetbrains.dokka.gradle
 
 import com.android.build.gradle.api.AndroidSourceSet
-import com.fasterxml.jackson.annotation.JsonIgnore
 import groovy.lang.Closure
 import org.gradle.api.Action
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.SetProperty
 import org.gradle.api.tasks.*
+import org.gradle.kotlin.dsl.listProperty
+import org.gradle.kotlin.dsl.property
+import org.gradle.kotlin.dsl.setProperty
 import org.gradle.util.ConfigureUtil
 import org.jetbrains.dokka.*
 import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
@@ -16,98 +22,110 @@ import java.io.File
 import java.net.URL
 import org.jetbrains.kotlin.gradle.model.SourceSet as KotlinModelSourceSet
 
-
 internal fun Task.GradleDokkaSourceSetBuilderFactory(): (name: String) -> GradleDokkaSourceSetBuilder =
     { name -> GradleDokkaSourceSetBuilder(name, project) }
 
+
+// TODO NOW: Cover with tests
 open class GradleDokkaSourceSetBuilder constructor(
-    @get:JsonIgnore @Transient @get:Input val name: String,
-    @get:JsonIgnore @Transient @get:Internal internal val project: Project
+    @Transient @get:Input val name: String,
+    @Transient @get:Internal internal val project: Project
 ) : DokkaConfigurationBuilder<DokkaSourceSetImpl> {
 
+    @Internal
+    val sourceSetID: DokkaSourceSetID = DokkaSourceSetID(project, name)
+
     @Classpath
     @Optional
-    val classpath: MutableSet<File> = mutableSetOf()
+    val classpath: ConfigurableFileCollection = project.files()
 
     @Input
     @Optional
-    var moduleDisplayName: String? = null
+    val moduleDisplayName: Property<String?> = project.objects.safeProperty()
 
     @Input
     @Optional
-    var displayName: String? = null
-
-    @get:Internal
-    val sourceSetID: DokkaSourceSetID = DokkaSourceSetID(project, name)
+    val displayName: Property<String?> = project.objects.safeProperty()
 
     @Nested
-    val sourceRoots: MutableSet<File> = mutableSetOf()
+    val sourceRoots: ConfigurableFileCollection = project.files()
 
     @Input
-    val dependentSourceSets: MutableSet<DokkaSourceSetID> = mutableSetOf()
+    val dependentSourceSets: SetProperty<DokkaSourceSetID> = project.objects.setProperty<DokkaSourceSetID>()
+        .convention(emptySet())
 
     @InputFiles
     @Optional
-    val samples: MutableSet<File> = mutableSetOf()
+    val samples: ConfigurableFileCollection = project.files()
 
     @InputFiles
     @Optional
-    val includes: MutableSet<File> = mutableSetOf()
+    val includes: ConfigurableFileCollection = project.files()
 
     @Input
-    var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
+    val includeNonPublic: Property<Boolean> = project.objects.safeProperty<Boolean>()
+        .safeConvention(DokkaDefaults.includeNonPublic)
 
     @Input
-    var includeRootPackage: Boolean = DokkaDefaults.includeRootPackage
+    val reportUndocumented: Property<Boolean> = project.objects.safeProperty<Boolean>()
+        .safeConvention(DokkaDefaults.reportUndocumented)
 
     @Input
-    var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
+    val skipEmptyPackages: Property<Boolean> = project.objects.safeProperty<Boolean>()
+        .safeConvention(DokkaDefaults.skipEmptyPackages)
 
     @Input
-    var skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages
+    val skipDeprecated: Property<Boolean> = project.objects.safeProperty<Boolean>()
+        .safeConvention(DokkaDefaults.skipDeprecated)
 
     @Input
-    var skipDeprecated: Boolean = DokkaDefaults.skipDeprecated
-
-    @Input
-    var jdkVersion: Int = DokkaDefaults.jdkVersion
+    val jdkVersion: Property<Int> = project.objects.safeProperty<Int>()
+        .safeConvention(DokkaDefaults.jdkVersion)
 
     @Nested
-    val sourceLinks: MutableSet<GradleSourceLinkBuilder> = mutableSetOf()
+    val sourceLinks: SetProperty<GradleSourceLinkBuilder> = project.objects.setProperty<GradleSourceLinkBuilder>()
+        .convention(emptySet())
 
     @Nested
-    val perPackageOptions: MutableList<GradlePackageOptionsBuilder> = mutableListOf()
+    val perPackageOptions: ListProperty<GradlePackageOptionsBuilder> =
+        project.objects.listProperty<GradlePackageOptionsBuilder>()
+            .convention(emptyList())
 
     @Nested
-    val externalDocumentationLinks: MutableSet<GradleExternalDocumentationLinkBuilder> = mutableSetOf()
+    val externalDocumentationLinks: SetProperty<GradleExternalDocumentationLinkBuilder> =
+        project.objects.setProperty<GradleExternalDocumentationLinkBuilder>()
+            .convention(emptySet())
 
     @Input
     @Optional
-    var languageVersion: String? = null
+    val languageVersion: Property<String?> = project.objects.safeProperty<String>()
 
     @Input
     @Optional
-    var apiVersion: String? = null
+    val apiVersion: Property<String?> = project.objects.safeProperty()
 
     @Input
-    var noStdlibLink: Boolean = DokkaDefaults.noStdlibLink
+    val noStdlibLink: Property<Boolean> = project.objects.property<Boolean>()
+        .convention(DokkaDefaults.noStdlibLink)
 
     @Input
-    var noJdkLink: Boolean = DokkaDefaults.noJdkLink
+    val noJdkLink: Property<Boolean> = project.objects.property<Boolean>()
+        .convention(DokkaDefaults.noJdkLink)
 
     @Input
-    var noAndroidSdkLink: Boolean = false
+    val noAndroidSdkLink: Property<Boolean> = project.objects.property<Boolean>()
+        .convention(false)
 
-    @Input
-    val suppressedFiles: MutableSet<File> = mutableSetOf()
+    @InputFiles
+    val suppressedFiles: ConfigurableFileCollection = project.files()
 
     @Input
     @Optional
-    var analysisPlatform: Platform? = null
+    val analysisPlatform: Property<Platform?> = project.objects.safeProperty()
 
     @Input
     @Optional
-    var platform: String? = null
+    val platform: Property<String?> = project.objects.safeProperty()
 
     fun DokkaSourceSetID(sourceSetName: String): DokkaSourceSetID {
         return DokkaSourceSetID(project, sourceSetName)
@@ -133,139 +151,73 @@ open class GradleDokkaSourceSetBuilder constructor(
         dependentSourceSets.add(sourceSetID)
     }
 
-    // TODO NOW: Cover with tests
+    fun kotlinSourceSet(kotlinSourceSet: KotlinSourceSet) {
+        configureWithKotlinSourceSet(kotlinSourceSet)
+    }
 
     fun sourceRoot(file: File) {
-        sourceRoots.add(file)
+        sourceRoots.from(file)
     }
 
     fun sourceRoot(path: String) {
-        sourceRoots.add(project.file(path))
+        sourceRoot(project.file(path))
     }
 
     fun sourceLink(c: Closure<Unit>) {
-        val configured = ConfigureUtil.configure(c, GradleSourceLinkBuilder())
+        val configured = ConfigureUtil.configure(c, GradleSourceLinkBuilder(project))
         sourceLinks.add(configured)
     }
 
     fun sourceLink(action: Action<in GradleSourceLinkBuilder>) {
-        val sourceLink = GradleSourceLinkBuilder()
+        val sourceLink = GradleSourceLinkBuilder(project)
         action.execute(sourceLink)
         sourceLinks.add(sourceLink)
     }
 
     fun perPackageOption(c: Closure<Unit>) {
-        val configured = ConfigureUtil.configure(c, GradlePackageOptionsBuilder())
+        val configured = ConfigureUtil.configure(c, GradlePackageOptionsBuilder(project))
         perPackageOptions.add(configured)
     }
 
     fun perPackageOption(action: Action<in GradlePackageOptionsBuilder>) {
-        val option = GradlePackageOptionsBuilder()
+        val option = GradlePackageOptionsBuilder(project)
         action.execute(option)
         perPackageOptions.add(option)
     }
 
     fun externalDocumentationLink(c: Closure<Unit>) {
-        val link = ConfigureUtil.configure(c, GradleExternalDocumentationLinkBuilder())
+        val link = ConfigureUtil.configure(c, GradleExternalDocumentationLinkBuilder(project))
         externalDocumentationLinks.add(link)
     }
 
     fun externalDocumentationLink(action: Action<in GradleExternalDocumentationLinkBuilder>) {
-        val link = GradleExternalDocumentationLinkBuilder()
+        val link = GradleExternalDocumentationLinkBuilder(project)
         action.execute(link)
         externalDocumentationLinks.add(link)
     }
 
     fun externalDocumentationLink(url: String, packageListUrl: String? = null) {
         externalDocumentationLinks.add(
-            GradleExternalDocumentationLinkBuilder().apply {
-                this.url = URL(url)
-                this.packageListUrl = URL(packageListUrl)
+            GradleExternalDocumentationLinkBuilder(project).apply {
+                this.url by URL(url)
+                this.packageListUrl by URL(packageListUrl)
             }
         )
     }
 
     fun externalDocumentationLink(url: URL, packageListUrl: URL? = null) {
         externalDocumentationLinks.add(
-            GradleExternalDocumentationLinkBuilder().apply {
-                this.url = url
+            GradleExternalDocumentationLinkBuilder(project).apply {
+                this.url by url
                 if (packageListUrl != null) {
-                    this.packageListUrl = packageListUrl
+                    this.packageListUrl by packageListUrl
                 }
             }
         )
     }
 
     override fun build(): DokkaSourceSetImpl {
-        val moduleDisplayName = moduleDisplayName ?: project.name
-
-        val displayName = displayName ?: name.substringBeforeLast("Main", platform.toString())
-
-        val externalDocumentationLinks = externalDocumentationLinks.map { it.build() }
-            .run {
-                if (noJdkLink) this
-                else this + ExternalDocumentationLink(
-                    url =
-                    if (jdkVersion < 11) "https://docs.oracle.com/javase/${jdkVersion}/docs/api/"
-                    else "https://docs.oracle.com/en/java/javase/${jdkVersion}/docs/api/java.base/",
-                    packageListUrl =
-                    if (jdkVersion < 11) "https://docs.oracle.com/javase/${jdkVersion}/docs/api/package-list"
-                    else "https://docs.oracle.com/en/java/javase/${jdkVersion}/docs/api/element-list"
-                )
-            }
-            .run {
-                if (noStdlibLink) this
-                else this + ExternalDocumentationLink("https://kotlinlang.org/api/latest/jvm/stdlib/")
-            }
-            .run {
-                if (noAndroidSdkLink || !project.isAndroidProject()) this
-                else this +
-                        ExternalDocumentationLink("https://developer.android.com/reference/") +
-                        ExternalDocumentationLink(
-                            url = URL("https://developer.android.com/reference/kotlin/"),
-                            packageListUrl = URL("https://developer.android.com/reference/androidx/package-list")
-                        )
-            }
-
-        val analysisPlatform = when {
-            analysisPlatform != null -> checkNotNull(analysisPlatform)
-
-            platform?.isNotBlank() == true -> when (val platform = platform.toString().toLowerCase()) {
-                "androidjvm", "android" -> Platform.jvm
-                "metadata" -> Platform.common
-                else -> Platform.fromString(platform)
-            }
-
-            else -> Platform.DEFAULT
-        }
-
-        val suppressedFiles = suppressedFiles + project.collectSuppressedFiles(sourceRoots.toSet())
-
-        return DokkaSourceSetImpl(
-            classpath = classpath.toSet(),
-            moduleDisplayName = moduleDisplayName,
-            displayName = displayName,
-            sourceSetID = sourceSetID,
-            sourceRoots = sourceRoots.toSet(),
-            dependentSourceSets = dependentSourceSets.toSet(),
-            samples = samples.toSet(),
-            includes = includes.toSet(),
-            includeNonPublic = includeNonPublic,
-            includeRootPackage = includeRootPackage,
-            reportUndocumented = reportUndocumented,
-            skipEmptyPackages = skipEmptyPackages,
-            skipDeprecated = skipDeprecated,
-            jdkVersion = jdkVersion,
-            sourceLinks = sourceLinks.build().toSet(),
-            perPackageOptions = perPackageOptions.build(),
-            externalDocumentationLinks = externalDocumentationLinks.toSet(),
-            languageVersion = languageVersion,
-            apiVersion = apiVersion,
-            noStdlibLink = noStdlibLink,
-            noJdkLink = noJdkLink,
-            suppressedFiles = suppressedFiles.toSet(),
-            analysisPlatform = analysisPlatform
-        )
+        return toDokkaSourceSetImpl()
     }
 }
 
@@ -280,15 +232,3 @@ fun GradleDokkaSourceSetBuilder.dependsOn(sourceSet: KotlinSourceSet) {
 fun GradleDokkaSourceSetBuilder.dependsOn(sourceSet: AndroidSourceSet) {
     dependsOn(DokkaSourceSetID(sourceSet.name))
 }
-
-// TODO NOW: Test
-private fun Project.collectSuppressedFiles(sourceRoots: Set<File>): Set<File> =
-    if (project.isAndroidProject()) {
-        val generatedRoot = project.buildDir.resolve("generated").absoluteFile
-        sourceRoots
-            .filter { it.startsWith(generatedRoot) }
-            .flatMap { it.walk().toList() }
-            .toSet()
-    } else {
-        emptySet()
-    }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleExternalDocumentationLinkBuilder.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleExternalDocumentationLinkBuilder.kt
index 84ad6c1e..2960ba23 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleExternalDocumentationLinkBuilder.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleExternalDocumentationLinkBuilder.kt
@@ -1,22 +1,28 @@
 package org.jetbrains.dokka.gradle
 
+import org.gradle.api.Project
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
 import org.jetbrains.dokka.DokkaConfigurationBuilder
 import org.jetbrains.dokka.ExternalDocumentationLink
 import org.jetbrains.dokka.ExternalDocumentationLinkImpl
 import java.net.URL
 
-class GradleExternalDocumentationLinkBuilder : DokkaConfigurationBuilder<ExternalDocumentationLinkImpl> {
+class GradleExternalDocumentationLinkBuilder(
+    @get:Internal internal val project: Project
+) :
+    DokkaConfigurationBuilder<ExternalDocumentationLinkImpl> {
     @Input
-    var url: URL? = null
+    val url: Property<URL?> = project.objects.safeProperty()
 
     @Input
-    var packageListUrl: URL? = null
+    val packageListUrl: Property<URL?> = project.objects.safeProperty()
 
     override fun build(): ExternalDocumentationLinkImpl {
         return ExternalDocumentationLink(
-            url = checkNotNull(url) { "url not specified " },
-            packageListUrl = packageListUrl
+            url = checkNotNull(url.getSafe()) { "url not specified " },
+            packageListUrl = packageListUrl.getSafe()
         )
     }
 }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradlePackageOptionsBuilder.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradlePackageOptionsBuilder.kt
index fdc0275e..854dc9a0 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradlePackageOptionsBuilder.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradlePackageOptionsBuilder.kt
@@ -2,35 +2,45 @@
 
 package org.jetbrains.dokka.gradle
 
+import org.gradle.api.Project
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
 import org.jetbrains.dokka.DokkaConfigurationBuilder
 import org.jetbrains.dokka.DokkaDefaults
 import org.jetbrains.dokka.PackageOptionsImpl
 
 
-class GradlePackageOptionsBuilder : DokkaConfigurationBuilder<PackageOptionsImpl> {
+class GradlePackageOptionsBuilder(
+    @get:Internal internal val project: Project
+) : DokkaConfigurationBuilder<PackageOptionsImpl> {
     @Input
-    var prefix: String = ""
+    val prefix: Property<String> = project.objects.safeProperty<String>()
+        .safeConvention("")
 
     @Input
-    var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
+    val includeNonPublic: Property<Boolean> = project.objects.safeProperty<Boolean>()
+        .safeConvention(D