Merge remote-tracking branch 'zub/dev-multiplatf' into kotlin-website-jonnyzzz

1 files changed, 52 insertions, 38 deletions

diff --git a/runners/gradle-plugin/src/main/kotlin/main.kt b/runners/gradle-plugin/src/main/kotlin/main.kt
index 78bf4978..91639e11 100644
--- a/runners/gradle-plugin/src/main/kotlin/main.kt
+++ b/runners/gradle-plugin/src/main/kotlin/main.kt
@@ -10,6 +10,7 @@ import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.*
 import org.gradle.api.tasks.Optional
+import org.gradle.api.tasks.compile.AbstractCompile
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.ReflectDsl.isNotInstance
 import org.jetbrains.dokka.gradle.ClassloaderContainer.fatJarClassLoader
@@ -71,7 +72,7 @@ open class DokkaTask : DefaultTask() {
         description = "Generates dokka documentation for Kotlin"
 
         @Suppress("LeakingThis")
-        dependsOn(Callable { kotlinTasks.flatMap { it.dependsOn } })
+        dependsOn(Callable { kotlinTasks.map { it.taskDependencies } })
     }
 
     @Input
@@ -123,6 +124,9 @@ open class DokkaTask : DefaultTask() {
 
     @Input var noStdlibLink: Boolean = false
 
+    @Input
+    var noJdkLink: Boolean = false
+
     @Optional @Input
     var cacheRoot: String? = null
 
@@ -133,7 +137,10 @@ open class DokkaTask : DefaultTask() {
     @Optional @Input
     var apiVersion: String? = null
 
-    @get:Input
+    @Input
+    var collectInheritedExtensionsFromLibraries: Boolean = false
+
+    @get:Internal
     internal val kotlinCompileBasedClasspathAndSourceRoots: ClasspathAndSourceRoots by lazy { extractClasspathAndSourceRootsFromKotlinTasks() }
 
 
@@ -201,7 +208,7 @@ open class DokkaTask : DefaultTask() {
         }
     }
 
-    internal data class ClasspathAndSourceRoots(val classpath: List<File>, val sourceRoots: List<File>) : Serializable
+    internal data class ClasspathAndSourceRoots(val classpathFileCollection: FileCollection, val sourceRoots: List<File>) : Serializable
 
     private fun extractKotlinCompileTasks(): List<Task> {
         val inputList = (kotlinTasksConfigurator.invoke() ?: emptyList()).filterNotNull()
@@ -228,6 +235,7 @@ open class DokkaTask : DefaultTask() {
         val allTasks = kotlinTasks
 
         val allClasspath = mutableSetOf<File>()
+        var allClasspathFileCollection: FileCollection = project.files()
         val allSourceRoots = mutableSetOf<File>()
 
         allTasks.forEach {
@@ -239,15 +247,20 @@ open class DokkaTask : DefaultTask() {
                 val abstractKotlinCompileClz = getAbstractKotlinCompileFor(it)!!
 
                 val taskClasspath: Iterable<File> =
-                        (it["compileClasspath", abstractKotlinCompileClz].takeIfIsProp()?.v() ?:
-                                it["getClasspath", abstractKotlinCompileClz]())
-
-                allClasspath += taskClasspath.filter { it.exists() }
+                        (it["getClasspath", AbstractCompile::class].takeIfIsFunc()?.invoke()
+                                ?: it["compileClasspath", abstractKotlinCompileClz].takeIfIsProp()?.v()
+                                ?: it["getClasspath", abstractKotlinCompileClz]())
+
+                if (taskClasspath is FileCollection) {
+                    allClasspathFileCollection += taskClasspath
+                } else {
+                    allClasspath += taskClasspath
+                }
                 allSourceRoots += taskSourceRoots.filter { it.exists() }
             }
         }
 
-        return ClasspathAndSourceRoots(allClasspath.toList(), allSourceRoots.toList())
+        return ClasspathAndSourceRoots(allClasspathFileCollection + project.files(allClasspath), allSourceRoots.toList())
     }
 
     private fun Iterable<File>.toSourceRoots(): List<SourceRoot> = this.filter { it.exists() }.map { SourceRoot().apply { path = it.path } }
@@ -280,29 +293,32 @@ open class DokkaTask : DefaultTask() {
             val bootstrapProxy: DokkaBootstrap = automagicTypedProxy(javaClass.classLoader, bootstrapInstance)
 
             val configuration = SerializeOnlyDokkaConfiguration(
-                    moduleName,
-                    fullClasspath.map { it.absolutePath },
-                    sourceRoots,
-                    samples.filterNotNull().map { project.file(it).absolutePath },
-                    includes.filterNotNull().map { project.file(it).absolutePath },
-                    outputDirectory,
-                    outputFormat,
-                    includeNonPublic,
-                    false,
-                    reportUndocumented,
-                    skipEmptyPackages,
-                    skipDeprecated,
-                    jdkVersion,
-                    true,
-                    linkMappings,
-                    impliedPlatforms,
-                    perPackageOptions,
-                    externalDocumentationLinks,
-                    noStdlibLink,
+                moduleName,
+                fullClasspath.map { it.absolutePath },
+                sourceRoots,
+                samples.filterNotNull().map { project.file(it).absolutePath },
+                includes.filterNotNull().map { project.file(it).absolutePath },
+                outputDirectory,
+                outputFormat,
+                includeNonPublic,
+                false,
+                reportUndocumented,
+                skipEmptyPackages,
+                skipDeprecated,
+                jdkVersion,
+                true,
+                linkMappings,
+                impliedPlatforms,
+                perPackageOptions,
+                externalDocumentationLinks,
+                noStdlibLink,
+                noJdkLink,
                     cacheRoot,
                     collectSuppressedFiles(sourceRoots),
                     languageVersion,
-                    apiVersion)
+                    apiVersion,
+                    collectInheritedExtensionsFromLibraries
+            )
 
 
             bootstrapProxy.configure(
@@ -351,15 +367,17 @@ open class DokkaTask : DefaultTask() {
     }
 
 
+    @Classpath
+    fun getInputClasspath(): FileCollection {
+        val (classpathFileCollection) = extractClasspathAndSourceRootsFromKotlinTasks()
+        return project.files(collectClasspathFromOldSources() + classpath) + classpathFileCollection
+    }
+
     @InputFiles
     fun getInputFiles(): FileCollection {
-        val (tasksClasspath, tasksSourceRoots) = extractClasspathAndSourceRootsFromKotlinTasks()
-
-        val fullClasspath = collectClasspathFromOldSources() + tasksClasspath + classpath
-
+        val (_, tasksSourceRoots) = extractClasspathAndSourceRootsFromKotlinTasks()
         return project.files(tasksSourceRoots.map { project.fileTree(it) }) +
                 project.files(collectSourceRoots().map { project.fileTree(File(it.path)) }) +
-                project.files(fullClasspath.map { project.fileTree(it) }) +
                 project.files(includes) +
                 project.files(samples.filterNotNull().map { project.fileTree(it) })
     }
@@ -385,11 +403,7 @@ class SourceRoot : DokkaConfiguration.SourceRoot, Serializable {
             field = File(value).absolutePath
         }
 
-    override var platforms: List<String> = arrayListOf()
-
-    override fun toString(): String {
-        return "${platforms.joinToString()}::$path"
-    }
+    override fun toString(): String = path
 }
 
 open class LinkMapping : Serializable, DokkaConfiguration.SourceLinkDefinition {