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

27 files changed, 792 insertions, 312 deletions

diff --git a/runners/android-gradle-plugin/build.gradle b/runners/android-gradle-plugin/build.gradle
index 5050fd87..72d1be9e 100644
--- a/runners/android-gradle-plugin/build.gradle
+++ b/runners/android-gradle-plugin/build.gradle
@@ -1,3 +1,4 @@
+import com.gradle.publish.DependenciesBuilder
 import org.jetbrains.CorrectShadowPublishing
 
 apply plugin: 'java'
@@ -13,7 +14,7 @@ tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
     kotlinOptions {
         freeCompilerArgs += "-Xjsr305=strict"
         languageVersion = "1.2"
-        apiVersion = "1.0"
+        apiVersion = "1.1"
         jvmTarget = "1.8"
     }
 }
@@ -87,6 +88,12 @@ pluginBundle {
         }
     }
 
+    withDependencies { List<Dependency> list ->
+        list.clear()
+        def builder = new DependenciesBuilder()
+        builder.addUniqueScopedDependencies(list, configurations.shadow, "compile")
+    }
+
     mavenCoordinates {
         groupId = "org.jetbrains.dokka"
         artifactId = "dokka-android-gradle-plugin"
diff --git a/runners/android-gradle-plugin/src/main/kotlin/mainAndroid.kt b/runners/android-gradle-plugin/src/main/kotlin/mainAndroid.kt
index f2261120..bd2e88c2 100644
--- a/runners/android-gradle-plugin/src/main/kotlin/mainAndroid.kt
+++ b/runners/android-gradle-plugin/src/main/kotlin/mainAndroid.kt
@@ -23,8 +23,12 @@ open class DokkaAndroidTask : DokkaTask() {
     @Input var noAndroidSdkLink: Boolean = false
 
     override fun collectSuppressedFiles(sourceRoots: List<SourceRoot>): List<String> {
-        val generatedSubpath = "${project.buildDir}/generated/source".replace("/", File.separator)
-        return sourceRoots.filter { generatedSubpath in it.path }.flatMap { File(it.path).walk().toList() }.map { it.absolutePath }
+        val generatedRoot = project.buildDir.resolve("generated").absoluteFile
+        return sourceRoots
+            .map { File(it.path) }
+            .filter { it.startsWith(generatedRoot) }
+            .flatMap { it.walk().toList() }
+            .map { it.absolutePath }
     }
 
     init {
diff --git a/runners/ant/src/main/kotlin/ant/dokka.kt b/runners/ant/src/main/kotlin/ant/dokka.kt
index d1b6bef5..023b4b7f 100644
--- a/runners/ant/src/main/kotlin/ant/dokka.kt
+++ b/runners/ant/src/main/kotlin/ant/dokka.kt
@@ -17,53 +17,101 @@ class AntLogger(val task: Task): DokkaLogger {
 
 class AntSourceLinkDefinition(var path: String? = null, var url: String? = null, var lineSuffix: String? = null)
 
-class AntSourceRoot(var path: String? = null, var platforms: String? = null) {
-    fun toSourceRoot(): SourceRootImpl? = path?.let {
-        path ->
-        SourceRootImpl(path, platforms?.split(',').orEmpty())
+class AntSourceRoot(var path: String? = null) {
+    fun toSourceRoot(): SourceRootImpl? = path?.let { path ->
+        SourceRootImpl(path)
     }
 }
 
-class AntPackageOptions(
-        override var prefix: String = "",
-        override var includeNonPublic: Boolean = false,
-        override var reportUndocumented: Boolean = true,
-        override var skipDeprecated: Boolean = false,
-        override var suppress: Boolean = false) : DokkaConfiguration.PackageOptions
-
+class TextProperty(var value: String = "")
+
+class AntPassConfig(task: Task) : DokkaConfiguration.PassConfiguration {
+    override var moduleName: String = ""
+    override val classpath: List<String>
+        get() = buildClassPath.list().toList()
+
+    override val sourceRoots: List<DokkaConfiguration.SourceRoot>
+        get() = sourcePath.list().map { SourceRootImpl(it) } + antSourceRoots.mapNotNull { it.toSourceRoot() }
+
+    override val samples: List<String>
+        get() = samplesPath.list().toList()
+    override val includes: List<String>
+        get() = includesPath.list().toList()
+    override var includeNonPublic: Boolean = false
+    override var includeRootPackage: Boolean = true
+    override var reportUndocumented: Boolean = false
+    override var skipEmptyPackages: Boolean = true
+    override var skipDeprecated: Boolean = false
+    override var jdkVersion: Int = 6
+    override val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition>
+        get() = antSourceLinkDefinition.map {
+            val path = it.path!!
+            val url = it.url!!
+            SourceLinkDefinitionImpl(File(path).canonicalFile.absolutePath, url, it.lineSuffix)
+        }
+    override val perPackageOptions: MutableList<DokkaConfiguration.PackageOptions> = mutableListOf()
+    override val externalDocumentationLinks: List<ExternalDocumentationLink>
+        get() = buildExternalLinksBuilders.map { it.build() } + defaultExternalDocumentationLinks
+
+    override var languageVersion: String? = null
+    override var apiVersion: String? = null
+    override var noStdlibLink: Boolean = false
+    override var noJdkLink: Boolean = false
+    override var suppressedFiles: MutableList<String> = mutableListOf()
+    override var collectInheritedExtensionsFromLibraries: Boolean = false
+    override var analysisPlatform: Platform = Platform.DEFAULT
+    override var targets: List<String> = listOf()
+        get() = buildTargets.filter { it.value != "" }
+            .map { it.value }
+
+    private val samplesPath: Path by lazy { Path(task.project) }
+    private val includesPath: Path by lazy { Path(task.project) }
+    private val buildClassPath: Path by lazy { Path(task.project) }
+    val sourcePath: Path by lazy { Path(task.project) }
+    val antSourceRoots: MutableList<AntSourceRoot> = mutableListOf()
+
+    private val buildTargets: MutableList<TextProperty> = mutableListOf()
+    private val buildExternalLinksBuilders: MutableList<ExternalDocumentationLink.Builder> = mutableListOf()
+    val antSourceLinkDefinition: MutableList<AntSourceLinkDefinition> = mutableListOf()
+
+    private val defaultExternalDocumentationLinks: List<DokkaConfiguration.ExternalDocumentationLink>
+        get() {
+            val links = mutableListOf<DokkaConfiguration.ExternalDocumentationLink>()
+            if (!noJdkLink)
+                links += DokkaConfiguration.ExternalDocumentationLink.Builder("http://docs.oracle.com/javase/$jdkVersion/docs/api/").build()
+
+            if (!noStdlibLink)
+                links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://kotlinlang.org/api/latest/jvm/stdlib/").build()
+            return links
+        }
 
-class DokkaAntTask: Task() {
-    var moduleName: String? = null
-    var outputDir: String? = null
-    var outputFormat: String = "html"
-    var impliedPlatforms: String = ""
-    var jdkVersion: Int = 6
 
-    var noStdlibLink: Boolean = false
+    fun setSamples(ref: Path) {
+        samplesPath.append(ref)
+    }
 
-    var skipDeprecated: Boolean = false
+    fun setSamplesRef(ref: Reference) {
+        samplesPath.createPath().refid = ref
+    }
 
-    var cacheRoot: String? = null
+    fun setInclude(ref: Path) {
+        includesPath.append(ref)
+    }
 
-    var languageVersion: String? = null
-    var apiVersion: String? = null
+    fun setClasspath(classpath: Path) {
+        buildClassPath.append(classpath)
+    }
 
-    val compileClasspath: Path by lazy { Path(getProject()) }
-    val sourcePath: Path by lazy { Path(getProject()) }
-    val samplesPath: Path by lazy { Path(getProject()) }
-    val includesPath: Path by lazy { Path(getProject()) }
+    fun createPackageOptions(): AntPackageOptions = AntPackageOptions().apply { perPackageOptions.add(this) }
 
-    val antSourceLinks: MutableList<AntSourceLinkDefinition> = arrayListOf()
-    val antSourceRoots: MutableList<AntSourceRoot> = arrayListOf()
-    val antPackageOptions: MutableList<AntPackageOptions> = arrayListOf()
-    val antExternalDocumentationLinks = mutableListOf<ExternalDocumentationLink.Builder>()
+    fun createSourceRoot(): AntSourceRoot = AntSourceRoot().apply {  antSourceRoots.add(this) }
 
-    fun setClasspath(classpath: Path) {
-        compileClasspath.append(classpath)
+    fun createTarget(): TextProperty = TextProperty().apply {
+            buildTargets.add(this)
     }
 
     fun setClasspathRef(ref: Reference) {
-        compileClasspath.createPath().refid = ref
+        buildClassPath.createPath().refid = ref
     }
 
     fun setSrc(src: Path) {
@@ -74,68 +122,66 @@ class DokkaAntTask: Task() {
         sourcePath.createPath().refid = ref
     }
 
-    fun setSamples(samples: Path) {
-        samplesPath.append(samples)
-    }
-
-    fun setSamplesRef(ref: Reference) {
-        samplesPath.createPath().refid = ref
-    }
-
-    fun setInclude(include: Path) {
-        includesPath.append(include)
-    }
-
     fun createSourceLink(): AntSourceLinkDefinition {
         val def = AntSourceLinkDefinition()
-        antSourceLinks.add(def)
+        antSourceLinkDefinition.add(def)
         return def
     }
 
-    fun createSourceRoot(): AntSourceRoot = AntSourceRoot().apply { antSourceRoots.add(this) }
+    fun createExternalDocumentationLink() =
+        ExternalDocumentationLink.Builder().apply { buildExternalLinksBuilders.add(this) }
 
-    fun createPackageOptions(): AntPackageOptions = AntPackageOptions().apply { antPackageOptions.add(this) }
+}
+
+class AntPackageOptions(
+        override var prefix: String = "",
+        override var includeNonPublic: Boolean = false,
+        override var reportUndocumented: Boolean = true,
+        override var skipDeprecated: Boolean = false,
+        override var suppress: Boolean = false) : DokkaConfiguration.PackageOptions
+
+class DokkaAntTask: Task(), DokkaConfiguration {
+
+    override var format: String = "html"
+    override var generateIndexPages: Boolean = false
+    override var outputDir: String = ""
+    override var impliedPlatforms: List<String> = listOf()
+        get() = buildImpliedPlatforms.map { it.value }.toList()
+    private val buildImpliedPlatforms: MutableList<TextProperty> = mutableListOf()
+
+    override var cacheRoot: String? = null
+    override val passesConfigurations: MutableList<AntPassConfig> = mutableListOf()
+
+    fun createPassConfig() = AntPassConfig(this).apply { passesConfigurations.add(this) }
+    fun createImpliedPlatform(): TextProperty = TextProperty().apply { buildImpliedPlatforms.add(this) }
 
-    fun createExternalDocumentationLink() = ExternalDocumentationLink.Builder().apply { antExternalDocumentationLinks.add(this) }
 
     override fun execute() {
-        if (sourcePath.list().isEmpty() && antSourceRoots.isEmpty()) {
-            throw BuildException("At least one source path needs to be specified")
-        }
-        if (moduleName == null) {
-            throw BuildException("Module name needs to be specified")
-        }
-        if (outputDir == null) {
-            throw BuildException("Output directory needs to be specified")
+        for (passConfig in passesConfigurations) {
+            if (passConfig.sourcePath.list().isEmpty() && passConfig.antSourceRoots.isEmpty()) {
+                throw BuildException("At least one source path needs to be specified")
+            }
+
+            if (passConfig.moduleName == "") {
+                throw BuildException("Module name needs to be specified and not empty")
+            }
+
+            for (sourceLink in passConfig.antSourceLinkDefinition) {
+                if (sourceLink.path == null) {
+                    throw BuildException("'path' attribute of a <sourceLink> element is required")
+                }
+
+                if (sourceLink.url == null) {
+                    throw BuildException("'url' attribute of a <sourceLink> element is required")
+                }
+            }
         }
-        val sourceLinks = antSourceLinks.map {
-            val path = it.path ?: throw BuildException("'path' attribute of a <sourceLink> element is required")
-            val url = it.url ?: throw BuildException("'url' attribute of a <sourceLink> element is required")
-            SourceLinkDefinitionImpl(File(path).canonicalFile.absolutePath, url, it.lineSuffix)
+
+        if (outputDir == "") {
+            throw BuildException("Output directory needs to be specified and not empty")
         }
 
-        val generator = DokkaGenerator(
-                AntLogger(this),
-                compileClasspath.list().toList(),
-                sourcePath.list().map { SourceRootImpl(it) } + antSourceRoots.mapNotNull { it.toSourceRoot() },
-                samplesPath.list().toList(),
-                includesPath.list().toList(),
-                moduleName!!,
-                DocumentationOptions(
-                        outputDir!!,
-                        outputFormat,
-                        skipDeprecated = skipDeprecated,
-                        sourceLinks = sourceLinks,
-                        jdkVersion = jdkVersion,
-                        impliedPlatforms = impliedPlatforms.split(','),
-                        perPackageOptions = antPackageOptions,
-                        externalDocumentationLinks = antExternalDocumentationLinks.map { it.build() },
-                        noStdlibLink = noStdlibLink,
-                        cacheRoot = cacheRoot,
-                        languageVersion = languageVersion,
-                        apiVersion = apiVersion
-                )
-        )
+        val generator = DokkaGenerator(this, AntLogger(this))
         generator.generate()
     }
 }
\ No newline at end of file
diff --git a/runners/cli/build.gradle b/runners/cli/build.gradle
index 7f733140..54f74b03 100644
--- a/runners/cli/build.gradle
+++ b/runners/cli/build.gradle
@@ -10,7 +10,12 @@ tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
     }
 }
 
+repositories {
+    mavenLocal()
+}
+
 dependencies {
     compile project(":core")
-    compile "com.github.spullara.cli-parser:cli-parser:1.1.1"
+//    compile "com.github.spullara.cli-parser:cli-parser:1.1.1"
+    compile "org.jetbrains:kotlinx.cli:0.1"
 }
diff --git a/runners/cli/src/main/kotlin/cli/DokkaArgumentsParser.kt b/runners/cli/src/main/kotlin/cli/DokkaArgumentsParser.kt
new file mode 100644
index 00000000..5d795da7
--- /dev/null
+++ b/runners/cli/src/main/kotlin/cli/DokkaArgumentsParser.kt
@@ -0,0 +1,185 @@
+package org.jetbrains.dokka
+
+import kotlinx.cli.*
+import kotlin.reflect.KProperty
+
+class ParseContext(val cli: CommandLineInterface = CommandLineInterface("dokka")) {
+    private val transformActions = mutableMapOf<KProperty<*>, (String) -> Unit>()
+    private val flagActions = mutableMapOf<KProperty<*>, () -> Unit>()
+
+    fun registerFlagAction(
+        keys: List<String>,
+        help: String,
+        property: KProperty<*>,
+        invoke: () -> Unit
+    ) {
+        if (property !in flagActions.keys) {
+            cli.flagAction(keys, help) {
+                flagActions[property]!!()
+            }
+        }
+        flagActions[property] = invoke
+
+    }
+
+    fun registerSingleOption(
+        keys: List<String>,
+        help: String,
+        property: KProperty<*>,
+        invoke: (String) -> Unit
+    ) {
+        if (property !in transformActions.keys) {
+            cli.singleAction(keys, help) {
+                transformActions[property]!!(it)
+            }
+        }
+        transformActions[property] = invoke
+    }
+
+    fun registerRepeatableOption(
+        keys: List<String>,
+        help: String,
+        property: KProperty<*>,
+        invoke: (String) -> Unit
+    ) {
+        if (property !in transformActions.keys) {
+            cli.repeatingAction(keys, help) {
+                transformActions[property]!!(it)
+            }
+        }
+        transformActions[property] = invoke
+    }
+
+    fun parse(args: Array<String>) {
+        cli.parseArgs(*args)
+    }
+
+}
+
+fun CommandLineInterface.singleAction(
+    keys: List<String>,
+    help: String,
+    invoke: (String) -> Unit
+) = registerAction(
+    object : FlagActionBase(keys, help) {
+        override fun invoke(arguments: ListIterator<String>) {
+            if (arguments.hasNext()) {
+                val msg = arguments.next()
+                invoke(msg)
+            }
+        }
+
+        override fun invoke() {
+            error("should be never called")
+        }
+    }
+)
+
+fun CommandLineInterface.repeatingAction(
+    keys: List<String>,
+    help: String,
+    invoke: (String) -> Unit
+) = registerAction(
+    object : FlagActionBase(keys, help) {
+        override fun invoke(arguments: ListIterator<String>) {
+            while (arguments.hasNext()) {
+                val message = arguments.next()
+
+                if (this@repeatingAction.getFlagAction(message) != null) {
+                    arguments.previous()
+                    break
+                }
+                invoke(message)
+            }
+        }
+
+        override fun invoke() {
+            error("should be never called")
+        }
+    }
+
+)
+
+
+class DokkaArgumentsParser(val args: Array<String>, val parseContext: ParseContext) {
+    class OptionDelegate<T>(
+        var value: T,
+        private val action: (delegate: OptionDelegate<T>, property: KProperty<*>) -> Unit
+    ) {
+        operator fun getValue(thisRef: Any?, property: KProperty<*>): T = value
+        operator fun provideDelegate(thisRef: Any, property: KProperty<*>): OptionDelegate<T> {
+            action(this, property)
+            return this
+        }
+    }
+
+    fun <T> parseInto(dest: T): T {
+        // TODO: constructor: (DokkaArgumentsParser) -> T
+        parseContext.parse(args)
+        return dest
+    }
+
+    fun <T> repeatableOption(
+        keys: List<String>,
+        help: String,
+        transform: (String) -> T
+    ) = OptionDelegate(mutableListOf<T>()) { delegate, property ->
+        parseContext.registerRepeatableOption(keys, help, property) {
+            delegate.value.add(transform(it))
+        }
+    }
+
+    fun <T : String?> repeatableOption(
+        keys: List<String>,
+        help: String
+    ) = repeatableOption(keys, help) { it as T }
+
+    fun <T> repeatableFlag(
+        keys: List<String>,
+        help: String,
+        initElement: (ParseContext) -> T
+    ) = OptionDelegate(mutableListOf<T>()) { delegate, property ->
+        parseContext.registerFlagAction(keys, help, property) {
+            delegate.value.add(initElement(parseContext))
+        }
+    }
+
+    fun <T> singleFlag(
+        keys: List<String>,
+        help: String,
+        initElement: (ParseContext) -> T,
+        transform: () -> T
+    ) = OptionDelegate(initElement(parseContext)) { delegate, property ->
+        parseContext.registerFlagAction(keys, help, property) {
+            delegate.value = transform()
+        }
+    }
+
+    fun singleFlag(
+        keys: List<String>,
+        help: String
+    ) = singleFlag(keys, help, { false }, { true })
+
+    fun <T : String?> stringOption(
+        keys: List<String>,
+        help: String,
+        defaultValue: T
+    ) = singleOption(keys, help, { it as T }, { defaultValue })
+
+    fun <T> singleOption(
+        keys: List<String>,
+        help: String,
+        transform: (String) -> T,
+        initElement: (ParseContext) -> T
+    ) = OptionDelegate(initElement(parseContext)) { delegate, property ->
+        parseContext.registerSingleOption(keys, help, property) {
+            val toAdd = transform(it)
+            delegate.value = toAdd
+        }
+    }
+}
+
+
+//`(-perPackage fqName [-include-non-public] [...other flags])*` (edited)
+//`(-sourceLink dir url [-urlSuffix value])*`
+//`(-extLink url [packageListUrl])*`
\ No newline at end of file
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index fe945ed3..655dfde5 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -1,72 +1,151 @@
 package org.jetbrains.dokka
 
-
-import com.sampullara.cli.Args
-import com.sampullara.cli.Argument
+import kotlinx.cli.registerAction
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
+import org.jetbrains.kotlin.daemon.common.compareDaemonJVMOptionsMemory
 
 import java.io.File
 import java.net.MalformedURLException
 import java.net.URL
 import java.net.URLClassLoader
 
-class DokkaArguments {
-    @set:Argument(value = "src", description = "Source file or directory (allows many paths separated by the system path separator)")
-    var src: String = ""
-
-    @set:Argument(value = "srcLink", description = "Mapping between a source directory and a Web site for browsing the code")
-    var srcLink: String = ""
-
-    @set:Argument(value = "include", description = "Markdown files to load (allows many paths separated by the system path separator)")
-    var include: String = ""
-
-    @set:Argument(value = "samples", description = "Source root for samples")
-    var samples: String = ""
-
-    @set:Argument(value = "output", description = "Output directory path")
-    var outputDir: String = "out/doc/"
-
-    @set:Argument(value = "format", description = "Output format (text, html, markdown, jekyll, kotlin-website)")
-    var outputFormat: String = "html"
-
-    @set:Argument(value = "module", description = "Name of the documentation module")
-    var moduleName: String = ""
-
-    @set:Argument(value = "classpath", description = "Classpath for symbol resolution")
-    var classpath: String = ""
-
-    @set:Argument(value = "nodeprecated", description = "Exclude deprecated members from documentation")
-    var nodeprecated: Boolean = false
-
-    @set:Argument(value = "jdkVersion", description = "Version of JDK to use for linking to JDK JavaDoc")
-    var jdkVersion: Int = 6
-
-    @set:Argument(value = "impliedPlatforms", description = "List of implied platforms (comma-separated)")
-    var impliedPlatforms: String = ""
-
-    @set:Argument(value = "packageOptions", description = "List of package options in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" ")
-    var packageOptions: String = ""
-
-    @set:Argument(value = "links", description = "External documentation links in format url^packageListUrl^^url2...")
-    var links: String = ""
-
-    @set:Argument(value = "noStdlibLink", description = "Disable documentation link to stdlib")
-    var noStdlibLink: Boolean = false
-
-    @set:Argument(value = "cacheRoot", description = "Path to cache folder, or 'default' to use ~/.cache/dokka, if not provided caching is disabled")
-    var cacheRoot: String? = null
-
-    @set:Argument(value = "languageVersion", description = "Language Version to pass to Kotlin Analysis")
-    var languageVersion: String? = null
-
-    @set:Argument(value = "apiVersion", description = "Kotlin Api Version to pass to Kotlin Analysis")
-    var apiVersion: String? = null
-
+open class GlobalArguments(parser: DokkaArgumentsParser) : DokkaConfiguration {
+    override val outputDir: String by parser.stringOption(
+        listOf("-output"),
+        "Output directory path",
+        "")
+
+    override val format: String by parser.stringOption(
+        listOf("-format"),
+        "Output format (text, html, markdown, jekyll, kotlin-website)",
+        "")
+
+    override val generateIndexPages: Boolean by parser.singleFlag(
+        listOf("-generateIndexPages"),
+        "Generate index page"
+    )
+
+    override val cacheRoot: String? by parser.stringOption(
+        listOf("-cacheRoot"),
+        "Path to cache folder, or 'default' to use ~/.cache/dokka, if not provided caching is disabled",
+        null)
+
+    override val impliedPlatforms: List<String> by parser.repeatableOption(
+        listOf("-impliedPlatforms"),
+        "List of implied platforms (comma-separated)"
+    )
+
+    override val passesConfigurations: List<Arguments> by parser.repeatableFlag(
+        listOf("-pass"),
+        "Single dokka pass"
+    ) {
+        Arguments(parser)
+    }
 }
 
+class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfiguration {
+    override val moduleName: String by parser.stringOption(
+        listOf("-module"),
+        "Name of the documentation module",
+        "")
+
+    override val classpath: List<String> by parser.repeatableOption(
+        listOf("-classpath"),
+        "Classpath for symbol resolution"
+    )
+
+    override val sourceRoots: List<DokkaConfiguration.SourceRoot> by parser.repeatableOption(
+        listOf("-src"),
+        "Source file or directory (allows many paths separated by the system path separator)"
+    ) { SourceRootImpl.parseSourceRoot(it) }
+
+    override val samples: List<String> by parser.repeatableOption(
+        listOf("-samples"),
+        "Source root for samples"
+    )
+
+    override val includes: List<String> by parser.repeatableOption(
+        listOf("-include"),
+        "Markdown files to load (allows many paths separated by the system path separator)"
+    )
+
+    override val includeNonPublic: Boolean by parser.singleFlag(
+        listOf("-includeNonPublic"),
+        "Include non public")
+
+    override val includeRootPackage: Boolean by parser.singleFlag(
+        listOf("-includeRootPackage"),
+        "Include non public")
+
+    override val reportUndocumented: Boolean by parser.singleFlag(
+        listOf("-reportUndocumented"),
+        "Include non public")
+
+    override val skipEmptyPackages: Boolean by parser.singleFlag(
+        listOf("-skipEmptyPackages"),
+        "Include non public")
+
+    override val skipDeprecated: Boolean by parser.singleFlag(
+        listOf("-skipDeprecated"),
+        "Include non public")
+
+    override val jdkVersion: Int by parser.singleOption(
+        listOf("jdkVersion"),
+        "Version of JDK to use for linking to JDK JavaDoc",
+        { it.toInt() },
+        { 6 }
+    )
+
+    override val languageVersion: String? by parser.stringOption(
+        listOf("-languageVersion"),
+        "Language Version to pass to Kotlin Analysis",
+        null)
+
+    override val apiVersion: String? by parser.stringOption(
+        listOf("-apiVesion"),
+        "Kotlin Api Version to pass to Kotlin Analysis",
+        null
+    )
+
+    override val noStdlibLink: Boolean by parser.singleFlag(
+        listOf("-noStdlibLink"),
+        "Disable documentation link to stdlib")
+
+    override val noJdkLink: Boolean by parser.singleFlag(
+        listOf("-noJdkLink"),
+        "Disable documentation link to stdlib")
+
+    override val suppressedFiles: List<String> by parser.repeatableOption(
+        listOf("-suppresedFiles"),
+        ""
+    )
+
+    override val collectInheritedExtensionsFromLibraries: Boolean by parser.singleFlag(
+        listOf("-collectInheritedExtensionsFromLibraries"),
+        "Search for applicable extensions in libraries")
+
+    override val analysisPlatform: Platform by parser.singleOption(
+        listOf("-analysisPlatform"),
+        "Platform for analysis",
+        { Platform.fromString(it) },
+        { Platform.DEFAULT }
+    )
+
+    override val targets: List<String> by parser.repeatableOption(
+        listOf("-targets"),
+        "Generation targets"
+    )
+
+
+
+    override val sourceLinks: MutableList<DokkaConfiguration.SourceLinkDefinition> = mutableListOf()
+
+    override val perPackageOptions: MutableList<DokkaConfiguration.PackageOptions> = mutableListOf()
+
+    override val externalDocumentationLinks: MutableList<DokkaConfiguration.ExternalDocumentationLink> = mutableListOf()
+}
 
 object MainKt {
-
     fun parseLinks(links: String): List<ExternalDocumentationLink> {
         val (parsedLinks, parsedOfflineLinks) = links.split("^^")
                 .map { it.split("^").map { it.trim() }.filter { it.isNotBlank() } }
@@ -87,48 +166,8 @@ object MainKt {
     }
 
     @JvmStatic
-    fun entry(args: Array<String>) {
-        val arguments = DokkaArguments()
-        val freeArgs: List<String> = Args.parse(arguments, args) ?: listOf()
-        val sources = if (arguments.src.isNotEmpty()) arguments.src.split(File.pathSeparatorChar).toList() + freeArgs else freeArgs
-        val samples = if (arguments.samples.isNotEmpty()) arguments.samples.split(File.pathSeparatorChar).toList() else listOf()
-        val includes = if (arguments.include.isNotEmpty()) arguments.include.split(File.pathSeparatorChar).toList() else listOf()
-
-        val sourceLinks = if (arguments.srcLink.isNotEmpty() && arguments.srcLink.contains("="))
-            listOf(SourceLinkDefinitionImpl.parseSourceLinkDefinition(arguments.srcLink))
-        else {
-            if (arguments.srcLink.isNotEmpty()) {
-                println("Warning: Invalid -srcLink syntax. Expected: <path>=<url>[#lineSuffix]. No source links will be generated.")
-            }
-            listOf()
-        }
-
-        val classPath = arguments.classpath.split(File.pathSeparatorChar).toList()
-
-        val documentationOptions = DocumentationOptions(
-                arguments.outputDir.let { if (it.endsWith('/')) it else it + '/' },
-                arguments.outputFormat,
-                skipDeprecated = arguments.nodeprecated,
-                sourceLinks = sourceLinks,
-                impliedPlatforms = arguments.impliedPlatforms.split(','),
-                perPackageOptions = parsePerPackageOptions(arguments.packageOptions),
-                jdkVersion = arguments.jdkVersion,
-                externalDocumentationLinks = parseLinks(arguments.links),
-                noStdlibLink = arguments.noStdlibLink,
-                cacheRoot = arguments.cacheRoot,
-                languageVersion = arguments.languageVersion,
-                apiVersion = arguments.apiVersion
-        )
-
-        val generator = DokkaGenerator(
-                DokkaConsoleLogger,
-                classPath,
-                sources.map(SourceRootImpl.Companion::parseSourceRoot),
-                samples,
-                includes,
-                arguments.moduleName,
-                documentationOptions)
-
+    fun entry(configuration: DokkaConfiguration) {
+        val generator = DokkaGenerator(configuration, DokkaConsoleLogger)
         generator.generate()
         DokkaConsoleLogger.report()
     }
@@ -154,27 +193,68 @@ object MainKt {
         return URLClassLoader(urls, ClassLoader.getSystemClassLoader().parent)
     }
 
-    fun startWithToolsJar(args: Array<String>) {
+    fun startWithToolsJar(configuration: DokkaConfiguration) {
         try {
             javaClass.classLoader.loadClass("com.sun.tools.doclets.formats.html.HtmlDoclet")
-            entry(args)
+            entry(configuration)
         } catch (e: ClassNotFoundException) {
             val classLoader = createClassLoaderWithTools()
             classLoader.loadClass("org.jetbrains.dokka.MainKt")
                     .methods.find { it.name == "entry" }!!
-                    .invoke(null, args)
+                    .invoke(null, configuration)
         }
     }
 
+    fun createConfiguration(args: Array<String>): GlobalArguments {
+        val parseContext = ParseContext()
+        val parser = DokkaArgumentsParser(args, parseContext)
+
+
+        val configuration = GlobalArguments(parser)
+
+
+        parseContext.cli.singleAction(
+                    listOf("-pckageOptions"),
+            "List of package passConfiguration in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
+        ) {
+            configuration.passesConfigurations.last().perPackageOptions.addAll(parsePerPackageOptions(it))
+        }
+
+        parseContext.cli.singleAction(
+            listOf("-links"),
+            "External documentation links in format url^packageListUrl^^url2..."
+        ) {
+            configuration.passesConfigurations.last().externalDocumentationLinks.addAll(MainKt.parseLinks(it))
+        }
+
+        parseContext.cli.singleAction(
+            listOf("-srcLink"),
+            "Mapping between a source directory and a Web site for browsing the code"
+        ) {
+            val newSourceLinks = if (it.isNotEmpty() && it.contains("="))
+                listOf(SourceLinkDefinitionImpl.parseSourceLinkDefinition(it))
+            else {
+                if (it.isNotEmpty()) {
+                    println("Warning: Invalid -srcLink syntax. Expected: <path>=<url>[#lineSuffix]. No source links will be generated.")
+                }
+                listOf()
+            }
+
+            configuration.passesConfigurations.last().sourceLinks.addAll(newSourceLinks)
+
+        }
+
+        parser.parseInto(configuration)
+        return configuration
+    }
+
     @JvmStatic
     fun main(args: Array<String>) {
-        val arguments = DokkaArguments()
-        Args.parse(arguments, args)
-
-        if (arguments.outputFormat == "javadoc")
-            startWithToolsJar(args)
+        val configuration = createConfiguration(args)
+        if (configuration.format == "javadoc")
+            startWithToolsJar(configuration)
         else
-            entry(args)
+            entry(configuration)
     }
 }
 
diff --git a/runners/gradle-integration-tests/build.gradle b/runners/gradle-integration-tests/build.gradle
index 1809589f..a681c82e 100644
--- a/runners/gradle-integration-tests/build.gradle
+++ b/runners/gradle-integration-tests/build.gradle
@@ -21,9 +21,8 @@ configurations {
 
 dependencies {
 
-    testCompile group: 'org.jetbrains.kotlin', name: 'kotlin-runtime', version: kotlin_for_gradle_runtime_version
-    testCompile group: 'org.jetbrains.kotlin', name: 'kotlin-reflect', version: kotlin_for_gradle_runtime_version
-    testCompile group: 'org.jetbrains.kotlin', name: 'kotlin-test', version: kotlin_for_gradle_runtime_version
+    testCompileOnly group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib', version: kotlin_for_gradle_runtime_version
+    testCompile group: 'org.jetbrains.kotlin', name: 'kotlin-test-junit', version: kotlin_for_gradle_runtime_version
     testCompile ideaRT()
 
     dokkaPlugin project(path: ':runners:gradle-plugin', configuration: 'shadow')
diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidAppTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidAppTest.kt
index ba70479f..bbb63909 100644
--- a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidAppTest.kt
+++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidAppTest.kt
@@ -17,4 +17,9 @@ class AndroidAppTest : AbstractAndroidAppTest("androidApp") {
     fun `test kotlin 1_0_7 and gradle 2_14_1 and abt 2_2_3`() {
         doTest("2.14.1", "1.0.7", AndroidPluginParams("2.2.3", "25.0.0", 24))
     }
+
+    @Test
+    fun `test kotlin 1_2_20 and gradle 4_5 and abt 3_0_1`() {
+        doTest("4.5", "1.2.20", AndroidPluginParams("3.0.1", "27.0.0", 27))
+    }
 }
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidLibDependsOnJavaLibTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidLibDependsOnJavaLibTest.kt
new file mode 100644
index 00000000..2a4ce712
--- /dev/null
+++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidLibDependsOnJavaLibTest.kt
@@ -0,0 +1,50 @@
+package org.jetbrains.dokka.gradle
+
+import org.gradle.testkit.runner.TaskOutcome
+import org.junit.Test
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.test.assertEquals
+
+class AndroidLibDependsOnJavaLibTest: AbstractDokkaAndroidGradleTest() {
+
+    private val testDataRootPath = "androidLibDependsOnJavaLib"
+
+    private fun prepareTestData() {
+        val testDataRoot = testDataFolder.resolve(testDataRootPath)
+        val tmpRoot = testProjectDir.root.toPath()
+
+        testDataRoot.copy(tmpRoot)
+
+        androidLocalProperties?.copy(tmpRoot.resolve("local.properties"))
+    }
+
+
+    private fun doTest(gradleVersion: String, kotlinVersion: String, androidPluginParams: AbstractAndroidAppTest.AndroidPluginParams) {
+        prepareTestData()
+
+        val result = configure(gradleVersion, kotlinVersion,
+                arguments = arrayOf("dokka", "--stacktrace") + androidPluginParams.asArguments())
+                .build()
+
+        println(result.output)
+
+        assertEquals(TaskOutcome.SUCCESS, result.task(":lib:dokka")?.outcome)
+
+        val docsOutput = "lib/build/dokka"
+
+        checkOutputStructure("$testDataRootPath/fileTree.txt", docsOutput)
+
+        checkNoErrorClasses(docsOutput)
+        checkNoUnresolvedLinks(docsOutput)
+
+        checkExternalLink(docsOutput, "<span class=\"identifier\">LibClz</span>",
+                """<a href="https://example.com/example/jlib/LibClz.html"><span class="identifier">LibClz</span></a>""")
+    }
+
+
+    @Test
+    fun `test kotlin 1_2_20 and gradle 4_5 and abt 3_0_1`() {
+        doTest("4.5", "1.2.20", AbstractAndroidAppTest.AndroidPluginParams("3.0.1", "27.0.0", 27))
+    }
+}
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidMultiFlavourAppTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidMultiFlavourAppTest.kt
index 28328af8..ef1b94d8 100644
--- a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidMultiFlavourAppTest.kt
+++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/AndroidMultiFlavourAppTest.kt
@@ -53,4 +53,8 @@ class AndroidMultiFlavourAppTest : AbstractDokkaAndroidGradleTest() {
         doTest("2.14.1", "1.0.7", AndroidPluginParams("2.2.3", "25.0.0", 24))
     }
 
+    @Test fun `test kotlin 1_2_20 and gradle 4_5 and abt 3_0_1`() {
+        doTest("4.5", "1.2.20", AndroidPluginParams("3.0.1", "27.0.0", 27))
+    }
+
 }
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/BasicTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/BasicTest.kt
index b1364004..ebaf1653 100644
--- a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/BasicTest.kt
+++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/BasicTest.kt
@@ -49,4 +49,7 @@ class BasicTest : AbstractDokkaGradleTest() {
         doTest("4.0", "1.1.2")
     }
 
+    @Test fun `test kotlin 1_2_20 and gradle 4_5`() {
+        doTest("4.5", "1.2.20")
+    }
 }
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/JavadocRSuppressionTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/JavadocRSuppressionTest.kt
index 511a033c..3a4d08b8 100644
--- a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/JavadocRSuppressionTest.kt
+++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/JavadocRSuppressionTest.kt
@@ -17,4 +17,8 @@ class JavadocRSuppressionTest : AbstractAndroidAppTest("androidAppJavadoc") {
     fun `test kotlin 1_0_7 and gradle 2_14_1 and abt 2_2_3`() {
         doTest("2.14.1", "1.0.7", AndroidPluginParams("2.2.3", "25.0.0", 24))
     }
+
+    @Test fun `test kotlin 1_2_20 and gradle 4_5 and abt 3_0_1`() {
+        doTest("4.5", "1.2.20", AndroidPluginParams("3.0.1", "27.0.0", 27))
+    }
 }
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiProjectSingleOutTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiProjectSingleOutTest.kt
index 13c7c37e..9458528c 100644
--- a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiProjectSingleOutTest.kt
+++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiProjectSingleOutTest.kt
@@ -51,4 +51,7 @@ class MultiProjectSingleOutTest : AbstractDokkaGradleTest() {
         doTest("4.0", "1.1.2")
     }
 
+    @Test fun `test kotlin 1_2_20 and gradle 4_5`() {
+        doTest("4.5", "1.2.20")
+    }
 }
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/RebuildAfterSourceChangeTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/RebuildAfterSourceChangeTest.kt
index 42e79696..f712998c 100644
--- a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/RebuildAfterSourceChangeTest.kt
+++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/RebuildAfterSourceChangeTest.kt
@@ -66,4 +66,9 @@ class RebuildAfterSourceChangeTest : AbstractDokkaGradleTest() {
     fun `test kotlin 1_1_2 and gradle 4_0`() {
         doTest("4.0", "1.1.2")
     }
+
+    @Test
+    fun `test kotlin 1_2_20 and gradle 4_5`() {
+        doTest("4.5", "1.2.20")
+    }
 }
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/build.gradle b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/build.gradle
new file mode 100644
index 00000000..736668ab
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/build.gradle
@@ -0,0 +1,20 @@
+subprojects {
+    buildscript {
+        repositories {
+            mavenCentral()
+            jcenter()
+            maven { url 'https://maven.google.com' }
+            maven { url "https://dl.bintray.com/kotlin/kotlin-eap/" }
+            maven { url "https://dl.bintray.com/kotlin/kotlin-dev" }
+        }
+
+    }
+
+    repositories {
+        mavenCentral()
+        jcenter()
+        maven { url 'https://maven.google.com' }
+        maven { url "https://dl.bintray.com/kotlin/kotlin-eap/" }
+        maven { url "https://dl.bintray.com/kotlin/kotlin-dev" }
+    }
+}
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/fileTree.txt b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/fileTree.txt
new file mode 100644
index 00000000..6c96a01c
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/fileTree.txt
@@ -0,0 +1,14 @@
+/
+    lib/
+        alltypes/
+            index.html
+        example/
+            -lib-clz-use/
+                -init-.html
+                f.html
+                index.html
+            index.html
+        index-outline.html
+        index.html
+        package-list
+    style.css
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/jlib/build.gradle b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/jlib/build.gradle
new file mode 100644
index 00000000..bbfeb03c
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/jlib/build.gradle
@@ -0,0 +1 @@
+apply plugin: 'java'
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/jlib/src/main/java/example/jlib/LibClz.java b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/jlib/src/main/java/example/jlib/LibClz.java
new file mode 100644
index 00000000..1d9a6fb2
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/jlib/src/main/java/example/jlib/LibClz.java
@@ -0,0 +1,5 @@
+package example.jlib;
+
+public class LibClz {
+
+}
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/build.gradle b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/build.gradle
new file mode 100644
index 00000000..0f27d365
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/build.gradle
@@ -0,0 +1,39 @@
+buildscript {
+    dependencies {
+        classpath "com.android.tools.build:gradle:$abt_plugin_version"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$test_kotlin_version"
+    }
+}
+
+
+plugins {
+    id 'org.jetbrains.dokka-android'
+}
+
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'org.jetbrains.dokka-android'
+
+
+android {
+    compileSdkVersion Integer.parseInt(sdk_version)
+    buildToolsVersion abt_version
+
+    sourceSets {
+        main.java.srcDirs += 'src/main/kotlin'
+    }
+}
+
+dependencies {
+    api(project(":jlib"))
+}
+
+dokka {
+    dokkaFatJar = new File(dokka_fatjar)
+
+    externalDocumentationLink {
+        url = new URL("https://example.com")
+        packageListUrl = file("$rootDir/package-list").toURI().toURL()
+    }
+}
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/src/main/AndroidManifest.xml b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..267f6efd
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/src/main/AndroidManifest.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="example">
+</manifest>
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/src/main/kotlin/example/LibClzUse.kt b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/src/main/kotlin/example/LibClzUse.kt
new file mode 100644
index 00000000..d034a3a9
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/lib/src/main/kotlin/example/LibClzUse.kt
@@ -0,0 +1,13 @@
+package example
+
+import example.jlib.LibClz
+
+/**
+ * Uses jlib
+ */
+class LibClzUse {
+    /**
+     * Returns LibClz
+     */
+    fun f(): LibClz = LibClz()
+}
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/package-list b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/package-list
new file mode 100644
index 00000000..bf76058e
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/package-list
@@ -0,0 +1 @@
+example.jlib
\ No newline at end of file
diff --git a/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/settings.gradle b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/settings.gradle
new file mode 100644
index 00000000..5b4250a0
--- /dev/null
+++ b/runners/gradle-integration-tests/testData/androidLibDependsOnJavaLib/settings.gradle
@@ -0,0 +1,5 @@
+rootProject.name = "androidLibDependsOnJavaLib"
+
+
+include(":lib")
+include(":jlib")
\ No newline at end of file
diff --git a/runners/gradle-plugin/build.gradle b/runners/gradle-plugin/build.gradle
index 790f3132..661d432b 100644
--- a/runners/gradle-plugin/build.gradle
+++ b/runners/gradle-plugin/build.gradle
@@ -1,3 +1,5 @@
+import com.gradle.publish.DependenciesBuilder
+
 apply plugin: 'java'
 apply plugin: 'kotlin'
 
@@ -11,7 +13,7 @@ tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
     kotlinOptions {
         freeCompilerArgs += "-Xjsr305=strict"
         languageVersion = "1.2"
-        apiVersion = "1.0"
+        apiVersion = "1.1"
         jvmTarget = "1.8"
     }
 }
@@ -84,6 +86,12 @@ pluginBundle {
         }
     }
 
+    withDependencies { List<Dependency> list ->
+        list.clear()
+        def builder = new DependenciesBuilder()
+        builder.addUniqueScopedDependencies(list, configurations.shadow, "compile")
+    }
+
     mavenCoordinates {
         groupId = "org.jetbrains.dokka"
         artifactId = "dokka-gradle-plugin"
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 {
diff --git a/runners/maven-plugin/build.gradle b/runners/maven-plugin/build.gradle
index 0e8d6a4d..79a8c22b 100644
--- a/runners/maven-plugin/build.gradle
+++ b/runners/maven-plugin/build.gradle
@@ -1,4 +1,5 @@
 import groovy.io.FileType
+import org.jetbrains.CorrectShadowPublishing
 import org.jetbrains.CrossPlatformExec
 
 import java.nio.file.Files
@@ -27,6 +28,7 @@ dependencies {
     shadow "org.codehaus.plexus:plexus-utils:$plexus_utils_version"
     shadow "org.codehaus.plexus:plexus-archiver:$plexus_archiver_version"
     shadow "org.apache.maven.plugin-tools:maven-plugin-annotations:$maven_plugin_tools_version"
+    shadow "com.github.olivergondza:maven-jdk-tools-wrapper:0.1"
 }
 
 task generatePom() {
@@ -92,64 +94,14 @@ apply plugin: 'maven-publish'
 
 publishing {
     publications {
-        dokkaMavenPlugin(MavenPublication) { publication ->
+        dokkaMavenPlugin(MavenPublication) { MavenPublication publication ->
             artifactId = 'dokka-maven-plugin'
 
             artifact sourceJar {
                 classifier "sources"
             }
 
-            project.shadow.component(publication)
-
-            pom.withXml {
-                Node root = asNode()
-
-                def dependency = new XmlParser().parseText('''
-                <dependency>
-                    <groupId>com.sun</groupId>
-                    <artifactId>tools</artifactId>
-                    <version>1.8.0</version>
-                    <scope>system</scope>
-                    <systemPath>${toolsjar}</systemPath>
-                </dependency>
-                ''')
-
-                root.children().find {
-                    return it.name() == "dependencies"
-                }.append(dependency)
-
-                def profiles = new XmlParser().parseText('''
-                <profiles>
-                    <profile>
-                        <id>default-profile</id>
-                        <activation>
-                            <activeByDefault>true</activeByDefault>
-                            <file>
-                                <exists>${java.home}/../lib/tools.jar</exists>
-                            </file>
-                        </activation>
-                        <properties>
-                            <toolsjar>${java.home}/../lib/tools.jar</toolsjar>
-                        </properties>
-                    </profile>
-                    <profile>
-                        <id>mac-profile</id>
-                        <activation>
-                            <activeByDefault>false</activeByDefault>
-                            <file>
-                                <exists>${java.home}/../Classes/classes.jar</exists>
-                            </file>
-                        </activation>
-                        <properties>
-                            <toolsjar>${java.home}/../Classes/classes.jar</toolsjar>
-                        </properties>
-                    </profile>
-                </profiles>
-                ''')
-                root.append(profiles)
-            }
-
-
+            CorrectShadowPublishing.configure(publication, project)
         }
     }
 }
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 09da90c6..a2771306 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -36,9 +36,6 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     class SourceRoot : DokkaConfiguration.SourceRoot {
         @Parameter(required = true)
         override var path: String = ""
-
-        @Parameter
-        override var platforms: List<String> = emptyList()
     }
 
     class PackageOptions : DokkaConfiguration.PackageOptions {
@@ -104,6 +101,9 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     @Parameter(defaultValue = "false")
     var noStdlibLink: Boolean = false
 
+    @Parameter(defaultValue = "false")
+    var noJdkLink: Boolean = false
+
     @Parameter
     var cacheRoot: String? = null
 
@@ -122,29 +122,33 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             return
         }
 
-        val gen = DokkaGenerator(
-                MavenDokkaLogger(log),
-                classpath,
-                sourceDirectories.map { SourceRootImpl(it) } + sourceRoots,
-                samplesDirs,
-                includeDirs + includes,
-                moduleName,
-                DocumentationOptions(getOutDir(), getOutFormat(),
-                        sourceLinks = sourceLinks.map { SourceLinkDefinitionImpl(it.dir, it.url, it.urlSuffix) },
-                        jdkVersion = jdkVersion,
-                        skipDeprecated = skipDeprecated,
-                        skipEmptyPackages = skipEmptyPackages,
-                        reportUndocumented = reportNotDocumented,
-                        impliedPlatforms = impliedPlatforms,
-                        perPackageOptions = perPackageOptions,
-                        externalDocumentationLinks = externalDocumentationLinks.map { it.build() },
-                        noStdlibLink = noStdlibLink,
-                        cacheRoot = cacheRoot,
-                        languageVersion = languageVersion,
-                        apiVersion = apiVersion
-                )
+        val passConfiguration = PassConfigurationImpl(
+            sourceLinks = sourceLinks.map { SourceLinkDefinitionImpl(it.dir, it.url, it.urlSuffix) },
+            jdkVersion = jdkVersion,
+            skipDeprecated = skipDeprecated,
+            skipEmptyPackages = skipEmptyPackages,
+            reportUndocumented = reportNotDocumented,
+            perPackageOptions = perPackageOptions,
+            externalDocumentationLinks = externalDocumentationLinks.map { it.build() },
+            noStdlibLink = noStdlibLink,
+            noJdkLink = noJdkLink,
+            languageVersion = languageVersion,
+            apiVersion = apiVersion
+
+        )
+
+        val configuration = DokkaConfigurationImpl(
+            outputDir = getOutDir(),
+            format = getOutFormat(),
+            impliedPlatforms = impliedPlatforms,
+            cacheRoot = cacheRoot,
+            passesConfigurations = listOf(
+                passConfiguration
+            )
         )
 
+        val gen = DokkaGenerator(configuration, MavenDokkaLogger(log))
+
         gen.generate()
     }
 }