From b536699655e40c62cd603e1f98869786566604bd Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Tue, 10 Sep 2019 15:15:09 +0200
Subject: WIP on restructuring

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index 7741642b..a409c348 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,4 @@
-dokka_version_base=0.10.0
+dokka_version_base=0.10.1
 dokka_publication_channel=dokka
 
 # Kotlin compiler and plugin
-- 
cgit 


From cac42655cf60c8bfb27171af48df2ea25bb34f1e Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Thu, 28 Nov 2019 13:08:00 +0100
Subject: Bump dokka version

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index a409c348..e6d57eac 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,4 @@
-dokka_version_base=0.10.1
+dokka_version_base=0.11.0
 dokka_publication_channel=dokka
 
 # Kotlin compiler and plugin
-- 
cgit 


From 0073c4c547dafaae5d465d4c410a52fd7fdc818d Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Fri, 24 Jan 2020 14:41:33 +0100
Subject: Cherry-pick 'analysis_rewrite_1.3.61'

---
 .idea/codeStyles/codeStyleConfig.xml               |   1 +
 .idea/compiler.xml                                 |   2 +
 .idea/jarRepositories.xml                          |  10 +
 build.gradle                                       |  45 +--
 core/build.gradle                                  |   3 +-
 .../main/kotlin/analysis/AnalysisEnvironment.kt    | 375 ++++++++++++++-------
 .../main/kotlin/analysis/CoreKotlinCacheService.kt |  18 +-
 .../main/kotlin/analysis/CoreProjectFileIndex.kt   |  11 +-
 .../main/kotlin/analysis/DokkaAnalyzerFacades.kt   | 164 ---------
 .../main/kotlin/analysis/JavaResolveExtension.kt   |   7 +-
 .../DefaultDocumentationNodeMerger.kt              |   3 +-
 coreDependencies/build.gradle                      |  23 +-
 gradle.properties                                  |   8 +-
 .../dokka/gradle/MultiplatformProjectTest.kt       |   4 +-
 14 files changed, 321 insertions(+), 353 deletions(-)
 delete mode 100644 core/src/main/kotlin/analysis/DokkaAnalyzerFacades.kt

(limited to 'gradle.properties')

diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
index 79ee123c..6e6eec11 100644
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -1,5 +1,6 @@
 <component name="ProjectCodeStyleConfiguration">
   <state>
     <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
   </state>
 </component>
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index f165d41a..feb731d8 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -58,6 +58,8 @@
       <module name="dokka.runners.gradle-plugin.test" target="1.8" />
       <module name="dokka.runners.maven-plugin.main" target="1.8" />
       <module name="dokka.runners.maven-plugin.test" target="1.8" />
+      <module name="dokka.testApi.main" target="1.8" />
+      <module name="dokka.testApi.test" target="1.8" />
       <module name="fatjar_main" target="1.8" />
       <module name="fatjar_test" target="1.8" />
       <module name="gradle-integration-tests.org.jetbrains.dokka.gradle-integration-tests.main" target="1.8" />
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index 8e7bd752..b5925b37 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -76,5 +76,15 @@
       <option name="name" value="Google" />
       <option name="url" value="https://dl.google.com/dl/android/maven2/" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven10" />
+      <option name="name" value="maven10" />
+      <option name="url" value="https://kotlin.bintray.com/kotlin-plugin" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven6" />
+      <option name="name" value="maven6" />
+      <option name="url" value="https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/1.3.61/maven" />
+    </remote-repository>
   </component>
 </project>
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index 2dfc4e01..35fa8667 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,5 +1,3 @@
-import org.jetbrains.DependenciesVersionGetter
-
 allprojects {
     ext {
         if (!project.findProperty("dokka_version")) {
@@ -35,6 +33,8 @@ allprojects {
         jcenter()
         mavenCentral()
         mavenLocal()
+        maven { url 'https://kotlin.bintray.com/kotlin-plugin' }
+        maven { url 'https://www.jetbrains.com/intellij-repository/releases' }
         maven { url "https://dl.bintray.com/jetbrains/markdown" }
         maven { url "https://dl.bintray.com/kotlin/kotlin-eap" }
         maven { url "https://dl.bintray.com/kotlin/kotlin-dev" }
@@ -72,6 +72,21 @@ def bintrayPublication(project, List<String> _publications) {
 }
 
 
+configurations {
+    ideaIC
+    intellijCore
+}
+
+repositories {
+    maven { url 'https://kotlin.bintray.com/kotlin-plugin' }
+    maven { url 'https://www.jetbrains.com/intellij-repository/snapshots' }
+    maven { url 'https://www.jetbrains.com/intellij-repository/releases' }
+}
+
+dependencies {
+    intellijCore "com.jetbrains.intellij.idea:intellij-core:$idea_version"
+    ideaIC "com.jetbrains.intellij.idea:ideaIC:$idea_version"
+}
 
 def ideaRT() {
     return zipTree(project.configurations.ideaIC.singleFile).matching ({
@@ -102,30 +117,4 @@ allprojects {
         }
 
     }
-}
-
-ext.ivyrepo = {
-    artifactPattern("https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/[revision]/internal/[module](.[ext])")
-    artifactPattern("https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/[revision]/[module](.[ext])")
-    artifactPattern("https://teamcity.jetbrains.com/guestAuth/repository/download/IntelliJMarkdownParser_Build/[revision]/([module]_[ext]/)[module](.[ext])")
-}
-
-repositories {
-    ivy(ivyrepo)
-    maven { url 'https://www.jetbrains.com/intellij-repository/snapshots' }
-    maven { url 'https://www.jetbrains.com/intellij-repository/releases' }
-}
-
-configurations {
-    ideaIC
-    intellijCore
-}
-def versions = DependenciesVersionGetter.getVersions(project, bundled_kotlin_compiler_version)
-
-ext.ideaVersion = versions["idea.build.id"]
-ext.markdownVersion = versions["markdown.build.id"].replace("%20", " ")
-
-dependencies {
-    intellijCore "com.jetbrains.intellij.idea:intellij-core:$ideaVersion"
-    ideaIC "com.jetbrains.intellij.idea:ideaIC:$ideaVersion"
 }
\ No newline at end of file
diff --git a/core/build.gradle b/core/build.gradle
index 31833cf9..a7379595 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -34,10 +34,11 @@ dependencies {
     compile "org.jetbrains.kotlin:kotlin-compiler:$bundled_kotlin_compiler_version"
     compile "org.jetbrains.kotlin:kotlin-script-runtime:$bundled_kotlin_compiler_version"
 
-    compile "org.jetbrains:markdown:$markdownVersion"
+    compile "org.jetbrains:markdown:0.1.41"
 
     compile 'org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10'
 
+
     //tools.jar
 //    def toolsJar = files(((URLClassLoader) ToolProvider.getSystemToolClassLoader()).getURLs().findAll { it.path.endsWith("jar") })
 //    compileOnly toolsJar
diff --git a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
index 30a51136..36652242 100644
--- a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
+++ b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
@@ -3,8 +3,10 @@ package org.jetbrains.dokka.analysis
 import com.google.common.collect.ImmutableMap
 import com.intellij.core.CoreApplicationEnvironment
 import com.intellij.core.CoreModuleManager
+import com.intellij.mock.MockApplication
 import com.intellij.mock.MockComponentManager
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.module.ModuleManager
@@ -16,15 +18,14 @@ import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.util.io.URLUtil
 import org.jetbrains.dokka.Platform
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters
-import org.jetbrains.kotlin.analyzer.common.CommonAnalyzerFacade
+import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
+import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
-import org.jetbrains.kotlin.caches.project.LibraryModuleInfo
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.ContentRoot
@@ -41,20 +42,36 @@ import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.getService
 import org.jetbrains.kotlin.container.tryGetService
 import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.ide.konan.NativeLibraryInfo
+import org.jetbrains.kotlin.ide.konan.analyzer.NativeResolverForModuleFactory
+import org.jetbrains.kotlin.ide.konan.decompiler.KotlinNativeLoadingMetadataCache
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
+import org.jetbrains.kotlin.js.resolve.JsResolverForModuleFactory
+import org.jetbrains.kotlin.library.impl.createKotlinLibrary
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.CommonPlatforms
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms.unspecifiedJvmPlatform
+import org.jetbrains.kotlin.platform.konan.KonanPlatforms
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
+import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
-import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
-import org.jetbrains.kotlin.resolve.konan.platform.KonanPlatform
+import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModuleFactory
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
+import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerServices
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.types.KotlinType
@@ -62,6 +79,9 @@ import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 import java.io.File
 
+const val JAR_SEPARATOR = "!/"
+const val KLIB_EXTENSION = "klib"
+
 /**
  * Kotlin as a service entry point
  *
@@ -85,65 +105,83 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
             Platform.native -> EnvironmentConfigFiles.NATIVE_CONFIG_FILES
             Platform.js -> EnvironmentConfigFiles.JS_CONFIG_FILES
         }
+
         val environment = KotlinCoreEnvironment.createForProduction(this, configuration, configFiles)
         val projectComponentManager = environment.project as MockComponentManager
 
-        val projectFileIndex = CoreProjectFileIndex(environment.project,
-                environment.configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS))
-
+        val projectFileIndex = CoreProjectFileIndex(
+            environment.project,
+            environment.configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS)
+        )
 
         val moduleManager = object : CoreModuleManager(environment.project, this) {
             override fun getModules(): Array<out Module> = arrayOf(projectFileIndex.module)
         }
 
-        CoreApplicationEnvironment.registerComponentInstance(projectComponentManager.picoContainer,
-                ModuleManager::class.java, moduleManager)
+        CoreApplicationEnvironment.registerComponentInstance(
+            projectComponentManager.picoContainer,
+            ModuleManager::class.java, moduleManager
+        )
 
         Extensions.registerAreaClass("IDEA_MODULE", null)
-        CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(),
-                OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java)
+        CoreApplicationEnvironment.registerExtensionPoint(
+            Extensions.getRootArea(),
+            OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java
+        )
+
+        projectComponentManager.registerService(
+            ProjectFileIndex::class.java,
+            projectFileIndex
+        )
+
+        projectComponentManager.registerService(
+            ProjectRootManager::class.java,
+            CoreProjectRootManager(projectFileIndex)
+        )
 
-        projectComponentManager.registerService(ProjectFileIndex::class.java,
-                projectFileIndex)
-        projectComponentManager.registerService(ProjectRootManager::class.java,
-                CoreProjectRootManager(projectFileIndex))
         return environment
     }
 
-    fun createSourceModuleSearchScope(project: Project, sourceFiles: List<KtFile>): GlobalSearchScope =
+    private fun createSourceModuleSearchScope(project: Project, sourceFiles: List<KtFile>): GlobalSearchScope =
         when (analysisPlatform) {
             Platform.jvm -> TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, sourceFiles)
-            Platform.js, Platform.common, Platform.native -> GlobalSearchScope.filesScope(project, sourceFiles.map { it.virtualFile }.toSet())
+            Platform.js, Platform.common, Platform.native -> GlobalSearchScope.filesScope(
+                project,
+                sourceFiles.map { it.virtualFile }.toSet()
+            )
         }
 
-
     fun createResolutionFacade(environment: KotlinCoreEnvironment): Pair<DokkaResolutionFacade, DokkaResolutionFacade> {
-
-        val projectContext = ProjectContext(environment.project)
+        val projectContext = ProjectContext(environment.project, "Dokka")
         val sourceFiles = environment.getSourceFiles()
 
 
         val targetPlatform = when (analysisPlatform) {
-            Platform.js -> JsPlatform
-            Platform.common -> TargetPlatform.Common
-            Platform.native -> KonanPlatform
-            Platform.jvm -> JvmPlatform
+            Platform.js -> JsPlatforms.defaultJsPlatform
+            Platform.common -> CommonPlatforms.defaultCommonPlatform
+            Platform.native -> KonanPlatforms.defaultKonanPlatform
+            Platform.jvm -> JvmPlatforms.defaultJvmPlatform
         }
 
-        val library = object : LibraryModuleInfo {
-            override val platform: TargetPlatform
-                get() = targetPlatform
-
-            override fun getLibraryRoots(): Collection<String> {
-                return classpath.map { it.absolutePath }
-            }
+        val nativeLibraries = classpath.filter { it.extension == KLIB_EXTENSION }
+            .map { createNativeLibraryModuleInfo(it) }
 
+        val library = object : LibraryModuleInfo {
+            override val analyzerServices: PlatformDependentAnalyzerServices =
+                analysisPlatform.analyzerServices()
             override val name: Name = Name.special("<library>")
+            override val platform: TargetPlatform = targetPlatform
             override fun dependencies(): List<ModuleInfo> = listOf(this)
+            override fun getLibraryRoots(): Collection<String> =
+                classpath.filterNot { it.extension == KLIB_EXTENSION }.map { it.absolutePath }
         }
+
         val module = object : ModuleInfo {
+            override val analyzerServices: PlatformDependentAnalyzerServices =
+                analysisPlatform.analyzerServices()
             override val name: Name = Name.special("<module>")
-            override fun dependencies(): List<ModuleInfo> = listOf(this, library)
+            override val platform: TargetPlatform = targetPlatform
+            override fun dependencies(): List<ModuleInfo> = listOf(this, library) + nativeLibraries
         }
 
         val sourcesScope = createSourceModuleSearchScope(environment.project, sourceFiles)
@@ -151,6 +189,7 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
             when (it) {
                 library -> ModuleContent(it, emptyList(), GlobalSearchScope.notScope(sourcesScope))
                 module -> ModuleContent(it, emptyList(), GlobalSearchScope.allScope(environment.project))
+                in nativeLibraries -> ModuleContent(it, emptyList(), GlobalSearchScope.notScope(sourcesScope))
                 else -> throw IllegalArgumentException("Unexpected module info")
             }
         }
@@ -159,20 +198,39 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
 
         val resolverForProject = when (analysisPlatform) {
             Platform.jvm -> {
-                builtIns = JvmBuiltIns(projectContext.storageManager)
-                createJvmResolverForProject(projectContext, module, library, modulesContent, sourcesScope, builtIns)
+                builtIns = JvmBuiltIns(
+                    projectContext.storageManager,
+                    JvmBuiltIns.Kind.FROM_CLASS_LOADER
+                ) // TODO we should use FROM_DEPENDENCIES
+                createJvmResolverForProject(
+                    projectContext,
+                    module,
+                    library,
+                    modulesContent,
+                    sourcesScope,
+                    builtIns
+                )
             }
-            Platform.common -> createCommonResolverForProject(projectContext, module, library, modulesContent, environment)
+            Platform.common -> createCommonResolverForProject(
+                projectContext,
+                module,
+                library,
+                modulesContent,
+                environment
+            )
             Platform.js -> createJsResolverForProject(projectContext, module, library, modulesContent)
             Platform.native -> createNativeResolverForProject(projectContext, module, library, modulesContent)
 
         }
-        val resolverForLibrary = resolverForProject.resolverForModule(library) // Required before module to initialize library properly
-        val resolverForModule = resolverForProject.resolverForModule(module)
         val libraryModuleDescriptor = resolverForProject.descriptorForModule(library)
         val moduleDescriptor = resolverForProject.descriptorForModule(module)
         builtIns?.initialize(moduleDescriptor, true)
-        val libraryResolutionFacade = DokkaResolutionFacade(environment.project, libraryModuleDescriptor, resolverForLibrary)
+
+        val resolverForLibrary =
+            resolverForProject.resolverForModule(library) // Required before module to initialize library properly
+        val resolverForModule = resolverForProject.resolverForModule(module)
+        val libraryResolutionFacade =
+            DokkaResolutionFacade(environment.project, libraryModuleDescriptor, resolverForLibrary)
         val created = DokkaResolutionFacade(environment.project, moduleDescriptor, resolverForModule)
         val projectComponentManager = environment.project as MockComponentManager
         projectComponentManager.registerService(KotlinCacheService::class.java, CoreKotlinCacheService(created))
@@ -180,29 +238,64 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         return created to libraryResolutionFacade
     }
 
+    private fun Platform.analyzerServices() = when (this) {
+        Platform.js -> JsPlatformAnalyzerServices
+        Platform.common -> CommonPlatformAnalyzerServices
+        Platform.native -> NativePlatformAnalyzerServices
+        Platform.jvm -> JvmPlatformAnalyzerServices
+    }
+
+    private fun createNativeLibraryModuleInfo(libraryFile: File): LibraryModuleInfo {
+        val kotlinLibrary = createKotlinLibrary(org.jetbrains.kotlin.konan.file.File(libraryFile.absolutePath), false)
+        return object : LibraryModuleInfo {
+            override val analyzerServices: PlatformDependentAnalyzerServices =
+                analysisPlatform.analyzerServices()
+            override val name: Name = Name.special("<klib>")
+            override val platform: TargetPlatform = KonanPlatforms.defaultKonanPlatform
+            override fun dependencies(): List<ModuleInfo> = listOf(this)
+            override fun getLibraryRoots(): Collection<String> = listOf(libraryFile.absolutePath)
+            override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>
+                get() = super.capabilities + (NativeLibraryInfo.NATIVE_LIBRARY_CAPABILITY to kotlinLibrary)
+        }
+    }
+
     private fun createCommonResolverForProject(
         projectContext: ProjectContext,
         module: ModuleInfo,
         library: LibraryModuleInfo,
         modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
         environment: KotlinCoreEnvironment
-    ): ResolverForProjectImpl<ModuleInfo> {
-        return ResolverForProjectImpl(
-            debugName = "Dokka",
-            projectContext = projectContext,
-            modules = listOf(module, library),
-            modulesContent = modulesContent,
-            modulePlatforms = { MultiTargetPlatform.Common },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { CommonAnalyzerFacade },
-            platformParameters = { _ ->
-                CommonAnalysisParameters { content ->
-                    environment.createPackagePartProvider(content.moduleContentScope)
-                }
-            },
-            targetEnvironment = CompilerEnvironment,
-            builtIns = DefaultBuiltIns.Instance
-        )
+    ): ResolverForProject<ModuleInfo> {
+        return object : AbstractResolverForProject<ModuleInfo>(
+            "Dokka",
+            projectContext,
+            modules = listOf(module, library)
+        ) {
+            override fun sdkDependency(module: ModuleInfo): ModuleInfo? = null
+
+            override fun modulesContent(module: ModuleInfo): ModuleContent<ModuleInfo> = modulesContent(module)
+
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = DefaultBuiltIns.Instance
+
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule =
+                CommonResolverForModuleFactory(
+                    CommonAnalysisParameters { content ->
+                        environment.createPackagePartProvider(content.moduleContentScope)
+                    },
+                    CompilerEnvironment,
+                    unspecifiedJvmPlatform,
+                    true
+                ).createResolverForModule(
+                    descriptor as ModuleDescriptorImpl,
+                    projectContext.withModule(descriptor),
+                    modulesContent(moduleInfo),
+                    this,
+                    LanguageVersionSettingsImpl.DEFAULT
+                )
+        }
     }
 
     private fun createJsResolverForProject(
@@ -210,19 +303,30 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         module: ModuleInfo,
         library: LibraryModuleInfo,
         modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
-    ): ResolverForProjectImpl<ModuleInfo> {
-        return ResolverForProjectImpl(
-            debugName = "Dokka",
-            projectContext = projectContext,
-            modules = listOf(module, library),
-            modulesContent = modulesContent,
-            modulePlatforms = { JsPlatform.multiTargetPlatform },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { DokkaJsAnalyzerFacade },
-            platformParameters = { _ -> PlatformAnalysisParameters.Empty },
-            targetEnvironment = CompilerEnvironment,
-            builtIns = JsPlatform.builtIns
-        )
+    ): ResolverForProject<ModuleInfo> {
+        return object : AbstractResolverForProject<ModuleInfo>(
+            "Dokka",
+            projectContext,
+            modules = listOf(module, library)
+        ) {
+            override fun modulesContent(module: ModuleInfo): ModuleContent<ModuleInfo> = modulesContent(module)
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule = JsResolverForModuleFactory(
+                CompilerEnvironment
+            ).createResolverForModule(
+                descriptor as ModuleDescriptorImpl,
+                projectContext.withModule(descriptor),
+                modulesContent(moduleInfo),
+                this,
+                LanguageVersionSettingsImpl.DEFAULT
+            )
+
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = DefaultBuiltIns.Instance
+
+            override fun sdkDependency(module: ModuleInfo): ModuleInfo? = null
+        }
     }
 
     private fun createNativeResolverForProject(
@@ -230,19 +334,39 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         module: ModuleInfo,
         library: LibraryModuleInfo,
         modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
-    ): ResolverForProjectImpl<ModuleInfo> {
-        return ResolverForProjectImpl(
-            debugName = "Dokka",
-            projectContext = projectContext,
-            modules = listOf(module, library),
-            modulesContent = modulesContent,
-            modulePlatforms = { KonanPlatform.multiTargetPlatform },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { DokkaNativeAnalyzerFacade },
-            platformParameters = { _ -> PlatformAnalysisParameters.Empty },
-            targetEnvironment = CompilerEnvironment
-        )
+    ): ResolverForProject<ModuleInfo> {
+        return object : AbstractResolverForProject<ModuleInfo>(
+            "Dokka",
+            projectContext,
+            modules = module.dependencies()
+        ) {
+            override fun modulesContent(module: ModuleInfo): ModuleContent<ModuleInfo> = modulesContent(module)
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule {
+                (ApplicationManager.getApplication() as MockApplication).addComponent(
+                    KotlinNativeLoadingMetadataCache::class.java,
+                    KotlinNativeLoadingMetadataCache()
+                )
+
+                return NativeResolverForModuleFactory(
+                    PlatformAnalysisParameters.Empty,
+                    CompilerEnvironment,
+                    KonanPlatforms.defaultKonanPlatform
+                ).createResolverForModule(
+                    descriptor as ModuleDescriptorImpl,
+                    projectContext.withModule(descriptor),
+                    modulesContent(moduleInfo),
+                    this,
+                    LanguageVersionSettingsImpl.DEFAULT
+                )
+            }
 
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = DefaultBuiltIns.Instance
+
+            override fun sdkDependency(module: ModuleInfo): ModuleInfo? = null
+        }
     }
 
     private fun createJvmResolverForProject(
@@ -252,38 +376,39 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
         sourcesScope: GlobalSearchScope,
         builtIns: KotlinBuiltIns
-    ): ResolverForProjectImpl<ModuleInfo> {
+    ): ResolverForProject<ModuleInfo> {
         val javaRoots = classpath
             .mapNotNull {
-                val rootFile = when {
-                    it.extension == "jar" ->
-                        StandardFileSystems.jar().findFileByPath("${it.absolutePath}${URLUtil.JAR_SEPARATOR}")
-                    else ->
-                        StandardFileSystems.local().findFileByPath(it.absolutePath)
+                val rootFile = when (it.extension) {
+                    "jar" -> StandardFileSystems.jar().findFileByPath("${it.absolutePath}${JAR_SEPARATOR}")
+                    else -> StandardFileSystems.local().findFileByPath(it.absolutePath)
                 }
-
                 rootFile?.let { JavaRoot(it, JavaRoot.RootType.BINARY) }
             }
 
-        return ResolverForProjectImpl(
-            debugName = "Dokka",
-            projectContext = projectContext,
-            modules = listOf(library, module),
-            modulesContent = {
-                when (it) {
-                    library -> ModuleContent(it, emptyList(), GlobalSearchScope.notScope(sourcesScope))
-                    module -> ModuleContent(it, emptyList(), sourcesScope)
+        return object : AbstractResolverForProject<ModuleInfo>(
+            "Dokka",
+            projectContext,
+            modules = listOf(module, library)
+        ) {
+            override fun modulesContent(module: ModuleInfo): ModuleContent<ModuleInfo> =
+                when (module) {
+                    library -> ModuleContent(module, emptyList(), GlobalSearchScope.notScope(sourcesScope))
+                    module -> ModuleContent(module, emptyList(), sourcesScope)
                     else -> throw IllegalArgumentException("Unexpected module info")
                 }
-            },
-            modulePlatforms = { JvmPlatform.multiTargetPlatform },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { JvmAnalyzerFacade },
-            platformParameters = {
-                JvmPlatformParameters ({ content ->
+
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = builtIns
+
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule = JvmResolverForModuleFactory(
+                JvmPlatformParameters({ content ->
                     JvmPackagePartProvider(
                         configuration.languageVersionSettings,
-                        content.moduleContentScope)
+                        content.moduleContentScope
+                    )
                         .apply {
                             addRoots(javaRoots, messageCollector)
                         }
@@ -293,16 +418,25 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
                         module
                     else
                         library
-                })
-            },
-            targetEnvironment = CompilerEnvironment,
-            builtIns = builtIns
-        )
+                }),
+                CompilerEnvironment,
+                KonanPlatforms.defaultKonanPlatform
+            ).createResolverForModule(
+                descriptor as ModuleDescriptorImpl,
+                projectContext.withModule(descriptor),
+                modulesContent(moduleInfo),
+                this,
+                LanguageVersionSettingsImpl.DEFAULT
+            )
+
+            override fun sdkDependency(module: ModuleInfo): ModuleInfo? = null
+        }
     }
 
     fun loadLanguageVersionSettings(languageVersionString: String?, apiVersionString: String?) {
         val languageVersion = LanguageVersion.fromVersionString(languageVersionString) ?: LanguageVersion.LATEST_STABLE
-        val apiVersion = apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
+        val apiVersion =
+            apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
         configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
     }
 
@@ -339,8 +473,8 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
      */
     val sources: List<String>
         get() = configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
-                ?.filterIsInstance<KotlinSourceRoot>()
-                ?.map { it.path } ?: emptyList()
+            ?.filterIsInstance<KotlinSourceRoot>()
+            ?.map { it.path } ?: emptyList()
 
     /**
      * Adds list of paths to source roots.
@@ -374,9 +508,11 @@ fun contentRootFromPath(path: String): ContentRoot {
 }
 
 
-class DokkaResolutionFacade(override val project: Project,
-                            override val moduleDescriptor: ModuleDescriptor,
-                            val resolverForModule: ResolverForModule) : ResolutionFacade {
+class DokkaResolutionFacade(
+    override val project: Project,
+    override val moduleDescriptor: ModuleDescriptor,
+    val resolverForModule: ResolverForModule
+) : ResolutionFacade {
     override fun analyzeWithAllCompilerChecks(elements: Collection<KtElement>): AnalysisResult {
         throw UnsupportedOperationException()
     }
@@ -385,7 +521,10 @@ class DokkaResolutionFacade(override val project: Project,
         return resolverForModule.componentProvider.tryGetService(serviceClass)
     }
 
-    override fun resolveToDescriptor(declaration: KtDeclaration, bodyResolveMode: BodyResolveMode): DeclarationDescriptor {
+    override fun resolveToDescriptor(
+        declaration: KtDeclaration,
+        bodyResolveMode: BodyResolveMode
+    ): DeclarationDescriptor {
         return resolveSession.resolveToDescriptor(declaration)
     }
 
diff --git a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt b/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
index 509c4e10..bcf91225 100644
--- a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
+++ b/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
@@ -5,7 +5,6 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.diagnostics.KotlinSuppressCache
 
 
@@ -14,11 +13,24 @@ class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade
         return resolutionFacade
     }
 
-    override fun getResolutionFacadeByFile(file: PsiFile, platform: TargetPlatform): ResolutionFacade {
+    override fun getResolutionFacade(
+        elements: List<KtElement>,
+        platform: org.jetbrains.kotlin.platform.TargetPlatform
+    ): ResolutionFacade {
         return resolutionFacade
     }
 
-    override fun getResolutionFacadeByModuleInfo(moduleInfo: ModuleInfo, platform: TargetPlatform): ResolutionFacade? {
+    override fun getResolutionFacadeByFile(
+        file: PsiFile,
+        platform: org.jetbrains.kotlin.platform.TargetPlatform
+    ): ResolutionFacade? {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeByModuleInfo(
+        moduleInfo: ModuleInfo,
+        platform: org.jetbrains.kotlin.platform.TargetPlatform
+    ): ResolutionFacade? {
         return resolutionFacade
     }
 
diff --git a/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt b/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
index 6863a266..45138e39 100644
--- a/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
+++ b/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
@@ -15,6 +15,7 @@ import com.intellij.openapi.util.Condition
 import com.intellij.openapi.util.Key
 import com.intellij.openapi.util.UserDataHolderBase
 import com.intellij.openapi.vfs.StandardFileSystems
+import com.intellij.openapi.vfs.VfsUtilCore.getVirtualFileForJar
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.VirtualFileFilter
 import com.intellij.psi.search.GlobalSearchScope
@@ -328,7 +329,7 @@ class CoreProjectFileIndex(private val project: Project, contentRoots: List<Cont
             throw UnsupportedOperationException()
         }
 
-        override fun <R : Any?> processOrder(p0: RootPolicy<R>?, p1: R): R {
+        override fun <R : Any?> processOrder(p0: RootPolicy<R>, p1: R): R {
             throw UnsupportedOperationException()
         }
 
@@ -403,7 +404,7 @@ class CoreProjectFileIndex(private val project: Project, contentRoots: List<Cont
             throw UnsupportedOperationException()
         }
 
-        override fun isDependsOn(p0: Module?): Boolean {
+        override fun isDependsOn(p0: Module): Boolean {
             throw UnsupportedOperationException()
         }
 
@@ -515,7 +516,7 @@ class CoreProjectRootManager(val projectFileIndex: CoreProjectFileIndex) : Proje
         throw UnsupportedOperationException()
     }
 
-    override fun getContentRootsFromAllModules(): Array<out VirtualFile>? {
+    override fun getContentRootsFromAllModules(): Array<out VirtualFile> {
         throw UnsupportedOperationException()
     }
 
@@ -523,7 +524,7 @@ class CoreProjectRootManager(val projectFileIndex: CoreProjectFileIndex) : Proje
         throw UnsupportedOperationException()
     }
 
-    override fun setProjectSdkName(p0: String?) {
+    override fun setProjectSdkName(p0: String) {
         throw UnsupportedOperationException()
     }
 
@@ -558,7 +559,7 @@ class CoreProjectRootManager(val projectFileIndex: CoreProjectFileIndex) : Proje
 fun ContentRoot.contains(file: VirtualFile) = when (this) {
     is JvmContentRoot -> {
         val path = if (file.fileSystem.protocol == StandardFileSystems.JAR_PROTOCOL)
-            StandardFileSystems.getVirtualFileForJar(file)?.path ?: file.path
+            getVirtualFileForJar(file)?.path ?: file.path
         else
             file.path
         File(path).startsWith(this.file.absoluteFile)
diff --git a/core/src/main/kotlin/analysis/DokkaAnalyzerFacades.kt b/core/src/main/kotlin/analysis/DokkaAnalyzerFacades.kt
deleted file mode 100644
index c69ff645..00000000
--- a/core/src/main/kotlin/analysis/DokkaAnalyzerFacades.kt
+++ /dev/null
@@ -1,164 +0,0 @@
-package org.jetbrains.dokka.analysis
-
-import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.caches.project.LibraryModuleInfo
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.TargetPlatformVersion
-import org.jetbrains.kotlin.container.StorageComponentContainer
-import org.jetbrains.kotlin.container.get
-import org.jetbrains.kotlin.container.useImpl
-import org.jetbrains.kotlin.container.useInstance
-import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.frontend.di.configureModule
-import org.jetbrains.kotlin.ide.konan.KOTLIN_NATIVE_CURRENT_ABI_VERSION
-import org.jetbrains.kotlin.ide.konan.createPackageFragmentProvider
-import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.js.resolve.JsPlatform
-import org.jetbrains.kotlin.konan.file.File
-import org.jetbrains.kotlin.konan.library.createKonanLibrary
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.konan.platform.KonanPlatform
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
-import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
-import org.jetbrains.kotlin.serialization.js.createKotlinJavascriptPackageFragmentProvider
-import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
-
-fun createContainerForLazyResolve(
-    moduleContext: ModuleContext,
-    declarationProviderFactory: DeclarationProviderFactory,
-    bindingTrace: BindingTrace,
-    platform: TargetPlatform,
-    targetPlatformVersion: TargetPlatformVersion,
-    targetEnvironment: TargetEnvironment,
-    languageVersionSettings: LanguageVersionSettings
-): StorageComponentContainer = createContainer("LazyResolve", platform) {
-    configureModule(moduleContext, platform, targetPlatformVersion, bindingTrace)
-
-    useInstance(declarationProviderFactory)
-    useInstance(languageVersionSettings)
-
-    useImpl<AnnotationResolverImpl>()
-    useImpl<CompilerDeserializationConfiguration>()
-    targetEnvironment.configure(this)
-
-    useImpl<ResolveSession>()
-    useImpl<LazyTopDownAnalyzer>()
-}
-
-
-object DokkaJsAnalyzerFacade : ResolverForModuleFactory() {
-    override fun <M : ModuleInfo> createResolverForModule(
-        moduleDescriptor: ModuleDescriptorImpl,
-        moduleContext: ModuleContext,
-        moduleContent: ModuleContent<M>,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
-        resolverForProject: ResolverForProject<M>,
-        languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion
-    ): ResolverForModule {
-        val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent
-        val project = moduleContext.project
-        val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
-            project,
-            moduleContext.storageManager,
-            syntheticFiles,
-            moduleContentScope,
-            moduleInfo
-        )
-
-        val container = createContainerForLazyResolve(
-            moduleContext,
-            declarationProviderFactory,
-            BindingTraceContext(),
-            JsPlatform,
-            TargetPlatformVersion.NoVersion,
-            targetEnvironment,
-            languageVersionSettings
-        )
-        var packageFragmentProvider = container.get<ResolveSession>().packageFragmentProvider
-
-        if (moduleInfo is LibraryModuleInfo && moduleInfo.platform == JsPlatform) {
-            val providers = moduleInfo.getLibraryRoots()
-                .flatMap { KotlinJavascriptMetadataUtils.loadMetadata(it) }
-                .filter { it.version.isCompatible() }
-                .map { metadata ->
-                    val (header, packageFragmentProtos) =
-                        KotlinJavascriptSerializationUtil.readModuleAsProto(metadata.body, metadata.version)
-                    createKotlinJavascriptPackageFragmentProvider(
-                        moduleContext.storageManager, moduleDescriptor, header, packageFragmentProtos, metadata.version,
-                        container.get(), LookupTracker.DO_NOTHING
-                    )
-                }
-
-            if (providers.isNotEmpty()) {
-                packageFragmentProvider = CompositePackageFragmentProvider(listOf(packageFragmentProvider) + providers)
-            }
-        }
-
-        return ResolverForModule(packageFragmentProvider, container)
-    }
-
-    override val targetPlatform: TargetPlatform
-        get() = JsPlatform
-}
-
-object DokkaNativeAnalyzerFacade : ResolverForModuleFactory() {
-    override val targetPlatform: TargetPlatform
-        get() = KonanPlatform
-
-    override fun <M : ModuleInfo> createResolverForModule(
-        moduleDescriptor: ModuleDescriptorImpl,
-        moduleContext: ModuleContext,
-        moduleContent: ModuleContent<M>,
-        platformParameters: PlatformAnalysisParameters,
-        targetEnvironment: TargetEnvironment,
-        resolverForProject: ResolverForProject<M>,
-        languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion
-    ): ResolverForModule {
-
-        val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
-            moduleContext.project,
-            moduleContext.storageManager,
-            moduleContent.syntheticFiles,
-            moduleContent.moduleContentScope,
-            moduleContent.moduleInfo
-        )
-
-        val container = createContainerForLazyResolve(
-            moduleContext,
-            declarationProviderFactory,
-            BindingTraceContext(),
-            targetPlatform,
-            TargetPlatformVersion.NoVersion,
-            targetEnvironment,
-            languageVersionSettings
-        )
-
-        val packageFragmentProvider = container.get<ResolveSession>().packageFragmentProvider
-        val fragmentProviders = mutableListOf(packageFragmentProvider)
-
-        val moduleInfo = moduleContent.moduleInfo
-
-        if (moduleInfo is LibraryModuleInfo) {
-            moduleInfo.getLibraryRoots()
-                .filter { File(it).extension != "jar" }
-                .map { createKonanLibrary(File(it), KOTLIN_NATIVE_CURRENT_ABI_VERSION) }
-                .mapTo(fragmentProviders) {
-                    it.createPackageFragmentProvider(
-                        moduleContext.storageManager,
-                        languageVersionSettings,
-                        moduleDescriptor
-                    )
-                }
-
-        }
-
-        return ResolverForModule(CompositePackageFragmentProvider(fragmentProviders), container)
-    }
-}
diff --git a/core/src/main/kotlin/analysis/JavaResolveExtension.kt b/core/src/main/kotlin/analysis/JavaResolveExtension.kt
index 2b60a639..ab6bec9c 100644
--- a/core/src/main/kotlin/analysis/JavaResolveExtension.kt
+++ b/core/src/main/kotlin/analysis/JavaResolveExtension.kt
@@ -19,7 +19,6 @@
 package org.jetbrains.dokka.analysis
 
 import com.intellij.psi.*
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.descriptors.*
@@ -29,11 +28,9 @@ import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.structure.impl.*
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.psi.psiUtil.parameterIndex
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 
@@ -128,4 +125,4 @@ private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElemen
 }
 
 fun PsiElement.javaResolutionFacade() =
-    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatform)!!
+    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatforms.defaultJvmPlatform)!!
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
index cac9d44c..04a5d954 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
@@ -3,12 +3,11 @@ package org.jetbrains.dokka.transformers.documentation
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 
 internal object DefaultDocumentationNodeMerger : DocumentationNodeMerger {
     override fun invoke(modules: Collection<Module>, context: DokkaContext): Module {
         if (!modules.all { it.name == modules.first().name })
-            DokkaConsoleLogger.error("All module names need to be the same")
+            context.logger.error("All module names need to be the same")
         return Module(
             modules.first().name,
             merge(
diff --git a/coreDependencies/build.gradle b/coreDependencies/build.gradle
index 4677309c..2b166a93 100644
--- a/coreDependencies/build.gradle
+++ b/coreDependencies/build.gradle
@@ -1,36 +1,15 @@
-repositories {
-    ivy(ivyrepo)
-}
-
-configurations {
-    kotlin_plugin_full
-}
-
-dependencies {
-    final String ijVersion = "20" + ideaVersion.take(2) + "." + ideaVersion[2]
-    kotlin_plugin_full "teamcity:kotlin-plugin-$bundled_kotlin_compiler_version-IJ$ijVersion-1:$bundled_kotlin_compiler_version@zip"
-}
-
 def intellijCoreAnalysis() {
     return zipTree(project(":").configurations.intellijCore.singleFile).matching ({
         include("intellij-core-analysis.jar")
     })
 }
 
-def kotlinPluginDependency() {
-
-    return zipTree(project.configurations.kotlin_plugin_full.singleFile).matching({
-        include("Kotlin/lib/kotlin-plugin.jar")
-    })
-}
-
 apply plugin: 'java'
 apply plugin: 'com.github.johnrengelman.shadow'
 
 dependencies {
-    compile kotlinPluginDependency()
     compile intellijCoreAnalysis()
-    compile "teamcity:kotlin-ide-common:$bundled_kotlin_compiler_version"
+    compile "org.jetbrains.kotlin:kotlin-plugin-ij193:$kotlin_plugin_version" //TODO: parametrize ij version after 1.3.70
 }
 
 shadowJar {
diff --git a/gradle.properties b/gradle.properties
index e6d57eac..b0c74348 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,9 +2,11 @@ dokka_version_base=0.11.0
 dokka_publication_channel=dokka
 
 # Kotlin compiler and plugin
-bundled_kotlin_compiler_version=1.3.20-dev-564
-kotlin_version=1.3.30
-kotlin_for_gradle_runtime_version=1.1.60
+bundled_kotlin_compiler_version=1.3.61
+kotlin_version=1.3.61
+kotlin_plugin_version=1.3.61-release-180
+idea_version=192.5728.98
+kotlin_for_gradle_runtime_version=1.3.61
 language_version=1.3
 
 ant_version=1.9.6
diff --git a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiplatformProjectTest.kt b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiplatformProjectTest.kt
index 3e61d79e..6ab9fd52 100644
--- a/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiplatformProjectTest.kt
+++ b/runners/gradle-integration-tests/src/test/kotlin/org/jetbrains/dokka/gradle/MultiplatformProjectTest.kt
@@ -40,8 +40,8 @@ class MultiplatformProjectTest : AbstractDokkaGradleTest() {
         checkNoUnresolvedLinks(docsOutput)
     }
 
-    @Test fun `test kotlin 1_3_30 and gradle 4_7`() {
-        doTest("4.7", "1.3.30")
+    @Test fun `test kotlin 1_3_30 and gradle 4_9`() {
+        doTest("4.9", "1.3.30")
     }
 
     @Test fun `test kotlin 1_3_40 and gradle 4_10_3`() {
-- 
cgit 


From e99be615ce7c2c2b5c3ee5e3f8941c41c1e7a944 Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Fri, 31 Jan 2020 00:37:29 +0100
Subject: Bump Gradle version, migrate to Kotlin DSL, refactor publishing

---
 build.gradle                                       | 120 ---------------
 build.gradle.kts                                   |  43 ++++++
 buildSrc/build.gradle                              |  10 --
 buildSrc/build.gradle.kts                          |  14 ++
 .../org/jetbrains/CorrectShadowPublishing.groovy   |  40 -----
 .../org/jetbrains/DependenciesVersionGetter.groovy |  14 --
 .../org/jetbrains/PluginXmlTransformer.groovy      |  71 ---------
 .../main/kotlin/org/jetbrains/BintrayPublishing.kt |  29 ++++
 .../kotlin/org/jetbrains/DistMavenPublishing.kt    |  28 ++++
 .../src/main/kotlin/org/jetbrains/DokkaVersion.kt  |  19 +++
 core/build.gradle                                  |  72 ---------
 core/build.gradle.kts                              |  49 +++++++
 core/src/main/kotlin/DokkaBootstrap.kt             |  10 ++
 core/src/main/kotlin/Java/JavadocParser.kt         |   4 -
 core/src/main/kotlin/configuration.kt              |  98 +++++++++++++
 core/src/main/kotlin/defaultConfiguration.kt       |  74 ++++++++++
 .../kotlin/multiplatform/BasicMultiplatformTest.kt |   2 +-
 coreDependencies/build.gradle                      |  45 ------
 coreDependencies/build.gradle.kts                  |  43 ++++++
 gradle.properties                                  |   9 +-
 gradle/wrapper/gradle-wrapper.jar                  | Bin 55616 -> 58695 bytes
 gradle/wrapper/gradle-wrapper.properties           |   4 +-
 gradlew                                            |  29 ++--
 integration-tests/build.gradle                     |   7 -
 integration-tests/build.gradle.kts                 |   0
 .../gradle-integration-tests/build.gradle          |  60 --------
 .../gradle-integration-tests/build.gradle.kts      |  52 +++++++
 integration/build.gradle                           |  25 ----
 .../kotlin/org/jetbrains/dokka/DokkaBootstrap.kt   |  10 --
 .../main/kotlin/org/jetbrains/dokka/ReflectDsl.kt  |  72 ---------
 .../kotlin/org/jetbrains/dokka/configuration.kt    |  98 -------------
 .../org/jetbrains/dokka/defaultConfiguration.kt    |  74 ----------
 plugins/build.gradle                               |  25 ----
 plugins/build.gradle.kts                           |  11 ++
 plugins/mathjax/build.gradle                       |  17 ---
 plugins/mathjax/build.gradle.kts                   |   8 +
 plugins/xml/build.gradle                           |  17 ---
 plugins/xml/build.gradle.kts                       |   8 +
 runners/build.gradle                               |   7 -
 runners/build.gradle.kts                           |   6 +
 runners/cli/build.gradle                           |  16 --
 runners/cli/build.gradle.kts                       |  37 +++++
 runners/fatjar/build.gradle                        |  78 ----------
 runners/gradle-plugin/build.gradle                 | 108 --------------
 runners/gradle-plugin/build.gradle.kts             |  74 ++++++++++
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt |  10 +-
 .../org/jetbrains/dokka/gradle/ReflectDsl.kt       |  72 +++++++++
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |   2 +-
 runners/maven-plugin/build.gradle                  | 161 ---------------------
 runners/maven-plugin/build.gradle.kts              | 115 +++++++++++++++
 runners/maven-plugin/src/main/kotlin/DokkaMojo.kt  |   3 +-
 .../src/main/kotlin/MavenDokkaLogger.kt            |   6 +-
 settings.gradle                                    |  16 --
 settings.gradle.kts                                |  29 ++++
 testApi/build.gradle                               |  12 --
 testApi/build.gradle.kts                           |  29 ++++
 56 files changed, 873 insertions(+), 1219 deletions(-)
 delete mode 100644 build.gradle
 create mode 100644 build.gradle.kts
 delete mode 100644 buildSrc/build.gradle
 create mode 100644 buildSrc/build.gradle.kts
 delete mode 100644 buildSrc/src/main/groovy/org/jetbrains/CorrectShadowPublishing.groovy
 delete mode 100644 buildSrc/src/main/groovy/org/jetbrains/DependenciesVersionGetter.groovy
 delete mode 100644 buildSrc/src/main/groovy/org/jetbrains/PluginXmlTransformer.groovy
 create mode 100644 buildSrc/src/main/kotlin/org/jetbrains/BintrayPublishing.kt
 create mode 100644 buildSrc/src/main/kotlin/org/jetbrains/DistMavenPublishing.kt
 create mode 100644 buildSrc/src/main/kotlin/org/jetbrains/DokkaVersion.kt
 delete mode 100644 core/build.gradle
 create mode 100644 core/build.gradle.kts
 create mode 100644 core/src/main/kotlin/DokkaBootstrap.kt
 create mode 100644 core/src/main/kotlin/configuration.kt
 create mode 100644 core/src/main/kotlin/defaultConfiguration.kt
 delete mode 100644 coreDependencies/build.gradle
 create mode 100644 coreDependencies/build.gradle.kts
 delete mode 100644 integration-tests/build.gradle
 create mode 100644 integration-tests/build.gradle.kts
 delete mode 100644 integration-tests/gradle-integration-tests/build.gradle
 create mode 100644 integration-tests/gradle-integration-tests/build.gradle.kts
 delete mode 100644 integration/build.gradle
 delete mode 100644 integration/src/main/kotlin/org/jetbrains/dokka/DokkaBootstrap.kt
 delete mode 100644 integration/src/main/kotlin/org/jetbrains/dokka/ReflectDsl.kt
 delete mode 100644 integration/src/main/kotlin/org/jetbrains/dokka/configuration.kt
 delete mode 100644 integration/src/main/kotlin/org/jetbrains/dokka/defaultConfiguration.kt
 delete mode 100644 plugins/build.gradle
 create mode 100644 plugins/build.gradle.kts
 delete mode 100644 plugins/mathjax/build.gradle
 create mode 100644 plugins/mathjax/build.gradle.kts
 delete mode 100644 plugins/xml/build.gradle
 create mode 100644 plugins/xml/build.gradle.kts
 delete mode 100644 runners/build.gradle
 create mode 100644 runners/build.gradle.kts
 delete mode 100644 runners/cli/build.gradle
 create mode 100644 runners/cli/build.gradle.kts
 delete mode 100644 runners/fatjar/build.gradle
 delete mode 100644 runners/gradle-plugin/build.gradle
 create mode 100644 runners/gradle-plugin/build.gradle.kts
 create mode 100644 runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ReflectDsl.kt
 delete mode 100644 runners/maven-plugin/build.gradle
 create mode 100644 runners/maven-plugin/build.gradle.kts
 delete mode 100644 settings.gradle
 create mode 100644 settings.gradle.kts
 delete mode 100644 testApi/build.gradle
 create mode 100644 testApi/build.gradle.kts

(limited to 'gradle.properties')

diff --git a/build.gradle b/build.gradle
deleted file mode 100644
index 35fa8667..00000000
--- a/build.gradle
+++ /dev/null
@@ -1,120 +0,0 @@
-allprojects {
-    ext {
-        if (!project.findProperty("dokka_version")) {
-            final String buildNumber = System.getenv("BUILD_NUMBER")
-            dokka_version = dokka_version_base + (buildNumber == null || System.getenv("FORCE_SNAPSHOT") != null ? "-SNAPSHOT" : "-$buildNumber")
-        }
-    }
-
-    if (project == rootProject) {
-        println "Publication version: $dokka_version"
-    }
-
-    group 'org.jetbrains.dokka'
-    version dokka_version
-
-
-    buildscript {
-        repositories {
-            mavenCentral()
-            maven { url "https://dl.bintray.com/kotlin/kotlin-eap" }
-            maven { url "https://dl.bintray.com/kotlin/kotlin-dev" }
-            maven { url "https://plugins.gradle.org/m2/" }
-        }
-        dependencies {
-            classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
-            classpath 'com.github.jengelman.gradle.plugins:shadow:2.0.1'
-
-            classpath "com.gradle.publish:plugin-publish-plugin:0.9.10"
-        }
-    }
-
-    repositories {
-        jcenter()
-        mavenCentral()
-        mavenLocal()
-        maven { url 'https://kotlin.bintray.com/kotlin-plugin' }
-        maven { url 'https://www.jetbrains.com/intellij-repository/releases' }
-        maven { url "https://dl.bintray.com/jetbrains/markdown" }
-        maven { url "https://dl.bintray.com/kotlin/kotlin-eap" }
-        maven { url "https://dl.bintray.com/kotlin/kotlin-dev" }
-        maven { url "https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/$bundled_kotlin_compiler_version/maven" }
-        maven { url "https://kotlin.bintray.com/kotlinx" }
-        maven { url "https://dl.bintray.com/kotlin/kotlinx" }
-        maven { url "https://dl.bintray.com/orangy/maven" } // TODO: remove this repository when kotlinx.cli is available in maven
-    }
-}
-
-
-def bintrayPublication(project, List<String> _publications) {
-    configure(project, {
-        apply plugin: 'com.jfrog.bintray'
-
-        bintray {
-            user = System.getenv('BINTRAY_USER')
-            key = System.getenv('BINTRAY_KEY')
-
-            pkg {
-                repo = dokka_publication_channel
-                name = 'dokka'
-                userOrg = 'kotlin'
-                desc = 'Dokka, the Kotlin documentation tool'
-                vcsUrl = 'https://github.com/kotlin/dokka.git'
-                licenses = ['Apache-2.0']
-                version {
-                    name = dokka_version
-                }
-            }
-
-            publications = _publications
-        }
-    })
-}
-
-
-configurations {
-    ideaIC
-    intellijCore
-}
-
-repositories {
-    maven { url 'https://kotlin.bintray.com/kotlin-plugin' }
-    maven { url 'https://www.jetbrains.com/intellij-repository/snapshots' }
-    maven { url 'https://www.jetbrains.com/intellij-repository/releases' }
-}
-
-dependencies {
-    intellijCore "com.jetbrains.intellij.idea:intellij-core:$idea_version"
-    ideaIC "com.jetbrains.intellij.idea:ideaIC:$idea_version"
-}
-
-def ideaRT() {
-    return zipTree(project.configurations.ideaIC.singleFile).matching ({
-        include("lib/idea_rt.jar")
-    })
-}
-
-def repoLocation = uri(file("$buildDir/dist-maven"))
-
-allprojects {
-
-    task publishToDistMaven {
-        group "publishing"
-        description "Publishes all Maven publications to Maven repository 'distMaven'."
-        dependsOn tasks.withType(PublishToMavenRepository).matching {
-            it.repository == publishing.repositories.distMaven
-        }
-    }
-
-    plugins.withType(MavenPublishPlugin) {
-        publishing {
-            repositories {
-                maven {
-                    name 'distMaven'
-                    url repoLocation
-                }
-            }
-        }
-
-    }
-}
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 00000000..5540184a
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,43 @@
+import org.jetbrains.configureDistMaven
+import org.jetbrains.configureDokkaVersion
+
+plugins {
+    kotlin("jvm") apply false
+    id("com.jfrog.bintray") apply false
+}
+
+allprojects {
+    configureDokkaVersion()
+    val dokka_version: String by this
+
+    if (this == rootProject) {
+        println("Publication version: $dokka_version")
+    }
+    group = "org.jetbrains.dokka"
+    version = dokka_version
+
+    val language_version: String by project
+    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class).all {
+        kotlinOptions {
+            freeCompilerArgs += "-Xjsr305=strict"
+            languageVersion = language_version
+            apiVersion = language_version
+            jvmTarget = "1.8"
+        }
+    }
+
+    repositories {
+        jcenter()
+        mavenCentral()
+        mavenLocal()
+        maven(url = "https://dl.bintray.com/jetbrains/markdown/")
+    }
+
+    configureDistMaven()
+}
+
+subprojects {
+    apply {
+        plugin("org.jetbrains.kotlin.jvm")
+    }
+}
\ No newline at end of file
diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle
deleted file mode 100644
index b62b4150..00000000
--- a/buildSrc/build.gradle
+++ /dev/null
@@ -1,10 +0,0 @@
-apply plugin: 'groovy'
-repositories {
-    mavenCentral()
-    jcenter()
-    maven { url "https://dl.bintray.com/kotlin/kotlin-eap" }
-    maven { url "https://dl.bintray.com/kotlin/kotlin-dev" }
-}
-dependencies {
-    compile 'com.github.jengelman.gradle.plugins:shadow:2.0.4'
-}
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
new file mode 100644
index 00000000..aeec9540
--- /dev/null
+++ b/buildSrc/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    `kotlin-dsl`
+    groovy
+}
+
+repositories {
+    mavenCentral()
+    jcenter()
+}
+
+dependencies {
+    implementation("com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4")
+    implementation("com.github.jengelman.gradle.plugins:shadow:2.0.4")
+}
diff --git a/buildSrc/src/main/groovy/org/jetbrains/CorrectShadowPublishing.groovy b/buildSrc/src/main/groovy/org/jetbrains/CorrectShadowPublishing.groovy
deleted file mode 100644
index 62cc3d3c..00000000
--- a/buildSrc/src/main/groovy/org/jetbrains/CorrectShadowPublishing.groovy
+++ /dev/null
@@ -1,40 +0,0 @@
-package org.jetbrains
-
-import org.gradle.api.Project
-import org.gradle.api.artifacts.ModuleVersionIdentifier
-import org.gradle.api.artifacts.ProjectDependency
-import org.gradle.api.artifacts.SelfResolvingDependency
-import org.gradle.api.internal.artifacts.ivyservice.projectmodule.ProjectDependencyPublicationResolver
-import org.gradle.api.publish.maven.MavenPom
-import org.gradle.api.publish.maven.MavenPublication
-
-//https://github.com/johnrengelman/shadow/issues/334
-static void configure(MavenPublication publication, Project project) {
-    publication.artifact(project.tasks.shadowJar)
-
-
-    publication.pom { MavenPom pom ->
-        pom.withXml { xml ->
-            def dependenciesNode = xml.asNode().appendNode('dependencies')
-
-            project.configurations.shadow.allDependencies.each {
-                if (it instanceof ProjectDependency) {
-                    final ProjectDependencyPublicationResolver projectDependencyResolver = project.gradle.services.get(ProjectDependencyPublicationResolver)
-                    final ModuleVersionIdentifier identifier = projectDependencyResolver.resolve(ModuleVersionIdentifier, it)
-                    addDependency(dependenciesNode, identifier)
-                } else if (!(it instanceof SelfResolvingDependency)) {
-                    addDependency(dependenciesNode, it)
-                }
-
-            }
-        }
-    }
-}
-
-private static void addDependency(Node dependenciesNode, dep) {
-    def dependencyNode = dependenciesNode.appendNode('dependency')
-    dependencyNode.appendNode('groupId', dep.group)
-    dependencyNode.appendNode('artifactId', dep.name)
-    dependencyNode.appendNode('version', dep.version)
-    dependencyNode.appendNode('scope', 'compile')
-}
diff --git a/buildSrc/src/main/groovy/org/jetbrains/DependenciesVersionGetter.groovy b/buildSrc/src/main/groovy/org/jetbrains/DependenciesVersionGetter.groovy
deleted file mode 100644
index 194f11af..00000000
--- a/buildSrc/src/main/groovy/org/jetbrains/DependenciesVersionGetter.groovy
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.jetbrains
-
-import org.gradle.api.Project
-
-class DependenciesVersionGetter {
-    static Properties getVersions(Project project, String artifactVersionSelector) {
-        def dep = project.dependencies.create(group: 'teamcity', name: 'dependencies', version: artifactVersionSelector, ext: 'properties')
-        def file = project.configurations.detachedConfiguration(dep).resolve().first()
-
-        def prop = new Properties()
-        prop.load(new FileReader(file))
-        return prop
-    }
-}
diff --git a/buildSrc/src/main/groovy/org/jetbrains/PluginXmlTransformer.groovy b/buildSrc/src/main/groovy/org/jetbrains/PluginXmlTransformer.groovy
deleted file mode 100644
index e711388f..00000000
--- a/buildSrc/src/main/groovy/org/jetbrains/PluginXmlTransformer.groovy
+++ /dev/null
@@ -1,71 +0,0 @@
-package org.jetbrains
-
-import com.github.jengelman.gradle.plugins.shadow.relocation.RelocateClassContext
-import com.github.jengelman.gradle.plugins.shadow.relocation.Relocator
-import com.github.jengelman.gradle.plugins.shadow.transformers.Transformer
-import com.github.jengelman.gradle.plugins.shadow.transformers.TransformerContext
-import groovy.xml.XmlUtil
-import org.gradle.api.file.FileTreeElement
-import shadow.org.apache.tools.zip.ZipEntry
-import shadow.org.apache.tools.zip.ZipOutputStream
-
-public class PluginXmlTransformer implements Transformer {
-    private Map<String, Node> transformedPluginXmlFiles = new HashMap<>();
-
-    @Override
-    boolean canTransformResource(FileTreeElement fileTreeElement) {
-        return fileTreeElement.relativePath.segments.contains("META-INF") && fileTreeElement.name.endsWith(".xml")
-    }
-
-    @Override
-    void transform(TransformerContext context) {
-        def path = context.path
-        def inputStream = context.is
-        System.out.println(path)
-        Node node = new XmlParser().parse(inputStream)
-        relocateXml(node, context)
-        transformedPluginXmlFiles.put(path, node)
-    }
-
-    @Override
-    boolean hasTransformedResource() {
-        return !transformedPluginXmlFiles.isEmpty()
-    }
-
-    @Override
-    void modifyOutputStream(ZipOutputStream zipOutputStream) {
-        for (Map.Entry<String, Node> entry : transformedPluginXmlFiles.entrySet()) {
-            zipOutputStream.putNextEntry(new ZipEntry(entry.key))
-            XmlUtil.serialize(entry.value, zipOutputStream)
-        }
-    }
-
-    private static void relocateXml(Node node, TransformerContext context) {
-        Map attributes = node.attributes()
-        RelocateClassContext relocateClassContext = new RelocateClassContext()
-        relocateClassContext.stats = context.stats
-        for (Map.Entry entry : attributes.entrySet()) {
-            relocateClassContext.setClassName((String) entry.getValue())
-            entry.setValue(relocateClassName(relocateClassContext, context))
-        }
-        List<String> localText = node.localText()
-        if (localText.size() == 1) {
-            relocateClassContext.setClassName(localText[0])
-            node.setValue(relocateClassName(relocateClassContext, context))
-        }
-        node.children().each {
-            if (it instanceof Node) {
-                relocateXml((Node) it, context)
-            }
-        }
-    }
-
-    private static String relocateClassName(RelocateClassContext relocateContext, TransformerContext context) {
-        for (Relocator relocator : context.relocators) {
-            if (relocator.canRelocateClass(relocateContext)) {
-                return relocator.relocateClass(relocateContext)
-            }
-        }
-        return relocateContext.className
-    }
-}
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/org/jetbrains/BintrayPublishing.kt b/buildSrc/src/main/kotlin/org/jetbrains/BintrayPublishing.kt
new file mode 100644
index 00000000..19e032a8
--- /dev/null
+++ b/buildSrc/src/main/kotlin/org/jetbrains/BintrayPublishing.kt
@@ -0,0 +1,29 @@
+package org.jetbrains
+
+import com.jfrog.bintray.gradle.BintrayExtension
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.provideDelegate
+
+fun Project.configureBintrayPublication(publication: String) = configureBintrayPublication(listOf(publication))
+
+fun Project.configureBintrayPublication(publications: List<String>) {
+    val dokka_version: String by this
+    val dokka_publication_channel: String by this
+    extensions.configure<BintrayExtension>("bintray") {
+        user = System.getenv("BINTRAY_USER")
+        key = System.getenv("BINTRAY_KEY")
+
+        pkg = PackageConfig().apply {
+            repo = dokka_publication_channel
+            name = "dokka"
+            userOrg = "kotlin"
+            desc = "Dokka, the Kotlin documentation tool"
+            vcsUrl = "https://github.com/kotlin/dokka.git"
+            setLicenses("Apache-2.0")
+            version = VersionConfig().apply {
+                name = dokka_version
+            }
+        }
+        setPublications(*publications.toTypedArray())
+    }
+}
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/org/jetbrains/DistMavenPublishing.kt b/buildSrc/src/main/kotlin/org/jetbrains/DistMavenPublishing.kt
new file mode 100644
index 00000000..ec536bd7
--- /dev/null
+++ b/buildSrc/src/main/kotlin/org/jetbrains/DistMavenPublishing.kt
@@ -0,0 +1,28 @@
+package org.jetbrains
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.repositories.MavenArtifactRepository
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
+
+fun Project.configureDistMaven() { // TODO: This can probably be written cleaner
+    val repoLocation = uri(file("${rootProject.buildDir}/dist-maven"))
+    var distMaven: MavenArtifactRepository? = null
+    pluginManager.withPlugin("maven-publish") {
+        this@configureDistMaven.extensions.findByType(PublishingExtension::class.java)?.let {
+            it.repositories {
+                distMaven = maven {
+                    name = "distMaven"
+                    url = repoLocation
+                }
+            }
+        }
+    }
+    tasks.register("publishToDistMaven") {
+        group = "publishing"
+        description = "Publishes all Maven publications to Maven repository 'distMaven'"
+        dependsOn(tasks.withType(PublishToMavenRepository::class.java).matching {
+            it.repository == distMaven
+        })
+    }
+}
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/org/jetbrains/DokkaVersion.kt b/buildSrc/src/main/kotlin/org/jetbrains/DokkaVersion.kt
new file mode 100644
index 00000000..5bd35415
--- /dev/null
+++ b/buildSrc/src/main/kotlin/org/jetbrains/DokkaVersion.kt
@@ -0,0 +1,19 @@
+package org.jetbrains
+
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.provideDelegate
+
+fun Project.configureDokkaVersion(): String {
+    var dokka_version: String? by this.extra
+    if (dokka_version == null) {
+        val buildNumber = System.getenv("BUILD_NUMBER")
+        val dokka_version_base: String by this
+        dokka_version = dokka_version_base + if (buildNumber == null || System.getenv("FORCE_SNAPSHOT") != null) {
+            "-SNAPSHOT"
+        } else {
+            "-$buildNumber"
+        }
+    }
+    return dokka_version!!
+}
\ No newline at end of file
diff --git a/core/build.gradle b/core/build.gradle
deleted file mode 100644
index a7379595..00000000
--- a/core/build.gradle
+++ /dev/null
@@ -1,72 +0,0 @@
-import javax.tools.ToolProvider
-
-buildscript {
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-allprojects {
-    apply plugin: 'kotlin'
-
-    sourceCompatibility = 1.8
-
-    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
-        kotlinOptions {
-            languageVersion = language_version
-            apiVersion = language_version
-            jvmTarget = "1.8"
-        }
-    }
-}
-
-dependencies {
-    testCompile project(':testApi')
-    compile project(":integration")
-    compile project(path: ":coreDependencies", configuration: "shadow")
-
-    compile "org.jetbrains.kotlin:kotlin-stdlib:$bundled_kotlin_compiler_version"
-    compile "org.jetbrains.kotlin:kotlin-reflect:$bundled_kotlin_compiler_version"
-
-    compile group: 'com.google.inject', name: 'guice', version: '3.0'
-    implementation "org.jsoup:jsoup:1.12.1"
-
-    compile "org.jetbrains.kotlin:kotlin-compiler:$bundled_kotlin_compiler_version"
-    compile "org.jetbrains.kotlin:kotlin-script-runtime:$bundled_kotlin_compiler_version"
-
-    compile "org.jetbrains:markdown:0.1.41"
-
-    compile 'org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10'
-
-
-    //tools.jar
-//    def toolsJar = files(((URLClassLoader) ToolProvider.getSystemToolClassLoader()).getURLs().findAll { it.path.endsWith("jar") })
-//    compileOnly toolsJar
-//    testCompile toolsJar
-
-
-    testCompile group: 'junit', name: 'junit', version: '4.12'
-    testCompile group: 'org.jetbrains.kotlin', name: 'kotlin-test-junit', version: kotlin_version
-    testCompile "com.nhaarman:mockito-kotlin-kt1.1:1.5.0"
-    implementation "com.google.code.gson:gson:$gson_version"
-
-    testImplementation "org.jetbrains.kotlin:kotlin-stdlib-js:$bundled_kotlin_compiler_version"
-    testImplementation "org.jetbrains.kotlin:kotlin-stdlib-common:$bundled_kotlin_compiler_version"
-//    testImplementation project(":core:testApi")
-
-    testCompile ideaRT()
-}
-
-apply plugin: 'maven-publish'
-
-publishing {
-    publications {
-        dokkaCore(MavenPublication) { publication ->
-            artifactId = 'dokka-core'
-
-            from components.java
-        }
-    }
-}
-
-bintrayPublication(project, ["dokkaCore"])
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
new file mode 100644
index 00000000..06610a38
--- /dev/null
+++ b/core/build.gradle.kts
@@ -0,0 +1,49 @@
+import org.jetbrains.configureBintrayPublication
+
+plugins {
+    id("com.github.johnrengelman.shadow")
+    `maven-publish`
+    id("com.jfrog.bintray")
+}
+
+dependencies {
+    implementation(project(":coreDependencies", configuration = "shadow"))
+
+    val kotlin_version: String by project
+    implementation("org.jetbrains.kotlin:kotlin-compiler:$kotlin_version")
+    implementation("org.jetbrains.kotlin:kotlin-script-runtime:$kotlin_version")
+    implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
+    implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlin_version")
+    implementation("org.jsoup:jsoup:1.12.1")
+    implementation("com.google.code.gson:gson:2.8.5")
+    implementation("org.jetbrains:markdown:0.1.40")
+    implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
+
+    testImplementation(project(":testApi"))
+    testImplementation("junit:junit:4.13")
+}
+
+tasks {
+    shadowJar {
+        val dokka_version: String by project
+        archiveFileName.set("dokka-core-$dokka_version.jar")
+        archiveClassifier.set("")
+    }
+}
+
+val sourceJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets["main"].allSource)
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("dokkaCore") {
+            artifactId = "dokka-core"
+            project.shadow.component(this)
+            artifact(sourceJar.get())
+        }
+    }
+}
+
+configureBintrayPublication("dokkaCore")
diff --git a/core/src/main/kotlin/DokkaBootstrap.kt b/core/src/main/kotlin/DokkaBootstrap.kt
new file mode 100644
index 00000000..b78eb9c6
--- /dev/null
+++ b/core/src/main/kotlin/DokkaBootstrap.kt
@@ -0,0 +1,10 @@
+package org.jetbrains.dokka
+
+import java.util.function.BiConsumer
+
+interface DokkaBootstrap {
+
+    fun configure(logger: BiConsumer<String, String>, serializedConfigurationJSON: String)
+
+    fun generate()
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Java/JavadocParser.kt b/core/src/main/kotlin/Java/JavadocParser.kt
index 5058634a..856cfa04 100644
--- a/core/src/main/kotlin/Java/JavadocParser.kt
+++ b/core/src/main/kotlin/Java/JavadocParser.kt
@@ -4,16 +4,12 @@ import com.intellij.psi.*
 import com.intellij.psi.impl.source.tree.JavaDocElementType
 import com.intellij.psi.javadoc.*
 import com.intellij.psi.util.PsiTreeUtil
-import com.intellij.util.containers.isNullOrEmpty
-import kotlinx.html.P
 import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.kotlin.utils.keysToMap
 import org.jsoup.Jsoup
 import org.jsoup.nodes.Element
 import org.jsoup.nodes.Node
 import org.jsoup.nodes.TextNode
-import java.net.URI
 
 interface JavaDocumentationParser {
     fun parseDocumentation(element: PsiNamedElement): DocumentationNode
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
new file mode 100644
index 00000000..8c6d35e8
--- /dev/null
+++ b/core/src/main/kotlin/configuration.kt
@@ -0,0 +1,98 @@
+package org.jetbrains.dokka
+
+import java.io.File
+import java.net.URL
+
+enum class Platform(val key: String) {
+    jvm("jvm"),
+    js("js"),
+    native("native"),
+    common("common");
+
+    companion object {
+        val DEFAULT = jvm
+
+        fun fromString(key: String): Platform {
+            return when (key.toLowerCase()) {
+                jvm.key -> jvm
+                js.key -> js
+                native.key -> native
+                common.key -> common
+                else -> throw IllegalArgumentException("Unrecognized platform: $key")
+            }
+        }
+    }
+}
+
+interface DokkaConfiguration {
+    val outputDir: String
+    val format: String
+    val generateIndexPages: Boolean
+    val cacheRoot: String?
+    val passesConfigurations: List<PassConfiguration>
+    val impliedPlatforms: List<String>
+    var pluginsClasspath: List<File>
+
+    interface PassConfiguration {
+        val moduleName: String
+        val classpath: List<String>
+        val sourceRoots: List<SourceRoot>
+        val samples: List<String>
+        val includes: List<String>
+        val includeNonPublic: Boolean
+        val includeRootPackage: Boolean
+        val reportUndocumented: Boolean
+        val skipEmptyPackages: Boolean
+        val skipDeprecated: Boolean
+        val jdkVersion: Int
+        val sourceLinks: List<SourceLinkDefinition>
+        val perPackageOptions: List<PackageOptions>
+        val externalDocumentationLinks: List<ExternalDocumentationLink>
+        val languageVersion: String?
+        val apiVersion: String?
+        val noStdlibLink: Boolean
+        val noJdkLink: Boolean
+        val suppressedFiles: List<String>
+        val collectInheritedExtensionsFromLibraries: Boolean
+        val analysisPlatform: Platform
+        val targets: List<String>
+        val sinceKotlin: String?
+    }
+
+    interface SourceRoot {
+        val path: String
+    }
+
+    interface SourceLinkDefinition {
+        val path: String
+        val url: String
+        val lineSuffix: String?
+    }
+
+    interface PackageOptions {
+        val prefix: String
+        val includeNonPublic: Boolean
+        val reportUndocumented: Boolean
+        val skipDeprecated: Boolean
+        val suppress: Boolean
+    }
+
+    interface ExternalDocumentationLink {
+        val url: URL
+        val packageListUrl: URL
+
+        open class Builder(open var url: URL? = null,
+                           open var packageListUrl: URL? = null) {
+
+            constructor(root: String, packageList: String? = null) : this(URL(root), packageList?.let { URL(it) })
+
+            fun build(): ExternalDocumentationLink =
+                if (packageListUrl != null && url != null)
+                    ExternalDocumentationLinkImpl(url!!, packageListUrl!!)
+                else if (url != null)
+                    ExternalDocumentationLinkImpl(url!!, URL(url!!, "package-list"))
+                else
+                    throw IllegalArgumentException("url or url && packageListUrl must not be null for external documentation link")
+        }
+    }
+}
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
new file mode 100644
index 00000000..6c797fcd
--- /dev/null
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -0,0 +1,74 @@
+package org.jetbrains.dokka
+
+import java.io.File
+import java.net.URL
+
+data class DokkaConfigurationImpl(
+    override val outputDir: String,
+    override val format: String,
+    override val generateIndexPages: Boolean,
+    override val cacheRoot: String?,
+    override val impliedPlatforms: List<String>,
+    override val passesConfigurations: List<PassConfigurationImpl>,
+    override var pluginsClasspath: List<File>
+) : DokkaConfiguration
+
+data class PassConfigurationImpl (
+    override val moduleName: String,
+    override val classpath: List<String>,
+    override val sourceRoots: List<SourceRootImpl>,
+    override val samples: List<String>,
+    override val includes: List<String>,
+    override val includeNonPublic: Boolean,
+    override val includeRootPackage: Boolean,
+    override val reportUndocumented: Boolean,
+    override val skipEmptyPackages: Boolean,
+    override val skipDeprecated: Boolean,
+    override val jdkVersion: Int,
+    override val sourceLinks: List<SourceLinkDefinitionImpl>,
+    override val perPackageOptions: List<PackageOptionsImpl>,
+    override var externalDocumentationLinks: List<ExternalDocumentationLinkImpl>,
+    override val languageVersion: String?,
+    override val apiVersion: String?,
+    override val noStdlibLink: Boolean,
+    override val noJdkLink: Boolean,
+    override val suppressedFiles: List<String>,
+    override val collectInheritedExtensionsFromLibraries: Boolean,
+    override val analysisPlatform: Platform,
+    override val targets: List<String>,
+    override val sinceKotlin: String?
+) : DokkaConfiguration.PassConfiguration
+
+
+data class SourceRootImpl(
+    override val path: String
+): DokkaConfiguration.SourceRoot
+
+data class SourceLinkDefinitionImpl(
+    override val path: String,
+    override val url: String,
+    override val lineSuffix: String?
+): DokkaConfiguration.SourceLinkDefinition {
+    companion object {
+        fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinitionImpl {
+            val (path, urlAndLine) = srcLink.split('=')
+            return SourceLinkDefinitionImpl(
+                File(path).canonicalPath,
+                urlAndLine.substringBefore("#"),
+                urlAndLine.substringAfter("#", "").let { if (it.isEmpty()) null else "#$it" })
+        }
+    }
+}
+
+data class PackageOptionsImpl(
+    override val prefix: String,
+    override val includeNonPublic: Boolean,
+    override val reportUndocumented: Boolean,
+    override val skipDeprecated: Boolean,
+    override val suppress: Boolean
+): DokkaConfiguration.PackageOptions
+
+
+data class ExternalDocumentationLinkImpl(override val url: URL,
+                                         override val packageListUrl: URL
+) : DokkaConfiguration.ExternalDocumentationLink
\ No newline at end of file
diff --git a/core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt b/core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
index ad165cdb..f9431bbb 100644
--- a/core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
+++ b/core/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
@@ -1,8 +1,8 @@
 package multiplatform
 
+import org.junit.Assert.assertEquals
 import org.junit.Test
 import testApi.testRunner.AbstractCoreTest
-import kotlin.test.assertEquals
 
 class BasicMultiplatformTest : AbstractCoreTest() {
 
diff --git a/coreDependencies/build.gradle b/coreDependencies/build.gradle
deleted file mode 100644
index 2b166a93..00000000
--- a/coreDependencies/build.gradle
+++ /dev/null
@@ -1,45 +0,0 @@
-def intellijCoreAnalysis() {
-    return zipTree(project(":").configurations.intellijCore.singleFile).matching ({
-        include("intellij-core-analysis.jar")
-    })
-}
-
-apply plugin: 'java'
-apply plugin: 'com.github.johnrengelman.shadow'
-
-dependencies {
-    compile intellijCoreAnalysis()
-    compile "org.jetbrains.kotlin:kotlin-plugin-ij193:$kotlin_plugin_version" //TODO: parametrize ij version after 1.3.70
-}
-
-shadowJar {
-    baseName = 'dokka-dependencies'
-    classifier = ''
-
-    configurations {
-        exclude compileOnly
-    }
-
-
-    exclude 'colorScheme/**'
-    exclude 'fileTemplates/**'
-    exclude 'inspectionDescriptions/**'
-    exclude 'intentionDescriptions/**'
-    exclude 'tips/**'
-    exclude 'messages/**'
-
-    exclude 'src/**'
-}
-
-apply plugin: 'maven-publish'
-
-publishing {
-    publications {
-        dokkaDependencies(MavenPublication) { publication ->
-            artifactId = 'dokka-dependencies'
-            project.shadow.component(publication)
-        }
-    }
-}
-
-bintrayPublication(project, ["dokkaDependencies"])
\ No newline at end of file
diff --git a/coreDependencies/build.gradle.kts b/coreDependencies/build.gradle.kts
new file mode 100644
index 00000000..514c7ae1
--- /dev/null
+++ b/coreDependencies/build.gradle.kts
@@ -0,0 +1,43 @@
+plugins {
+    id("com.github.johnrengelman.shadow")
+    `maven-publish`
+}
+
+val intellijCore: Configuration by configurations.creating
+
+repositories {
+    maven(url = "https://www.jetbrains.com/intellij-repository/snapshots")
+    maven(url = "https://www.jetbrains.com/intellij-repository/releases")
+    maven(url = "https://kotlin.bintray.com/kotlin-plugin")
+}
+
+fun intellijCoreAnalysis() = zipTree(intellijCore.singleFile).matching {
+    include("intellij-core-analysis.jar")
+}
+
+dependencies {
+    val idea_version: String by project
+    intellijCore("com.jetbrains.intellij.idea:intellij-core:$idea_version")
+    val kotlin_plugin_version: String by project
+    implementation(intellijCoreAnalysis())
+    implementation("org.jetbrains.kotlin:kotlin-plugin-ij193:$kotlin_plugin_version") {
+        //TODO: parametrize ij version after 1.3.70
+        isTransitive = false
+    }
+}
+
+tasks {
+    shadowJar {
+        val dokka_version: String by project
+        archiveFileName.set("dokka-dependencies-$dokka_version.jar")
+        archiveClassifier.set("")
+
+        exclude("colorScheme/**")
+        exclude("fileTemplates/**")
+        exclude("inspectionDescriptions/**")
+        exclude("intentionDescriptions/**")
+        exclude("tips/**")
+        exclude("messages/**")
+        exclude("src/**")
+    }
+}
diff --git a/gradle.properties b/gradle.properties
index b0c74348..57ddc095 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,11 +2,9 @@ dokka_version_base=0.11.0
 dokka_publication_channel=dokka
 
 # Kotlin compiler and plugin
-bundled_kotlin_compiler_version=1.3.61
 kotlin_version=1.3.61
 kotlin_plugin_version=1.3.61-release-180
 idea_version=192.5728.98
-kotlin_for_gradle_runtime_version=1.3.61
 language_version=1.3
 
 ant_version=1.9.6
@@ -14,12 +12,7 @@ ant_version=1.9.6
 # Maven plugin dependencies
 maven_version=3.5.0
 maven_archiver_version=2.5
-plexus_utils_version=3.0.22
-plexus_archiver_version=3.4
 maven_plugin_tools_version=3.5.2
 
 # For CI
-mvn=mvn
-
-# For serialization
-gson_version=2.8.5
\ No newline at end of file
+mvn=mvn
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 5c2d1cf0..f3d88b1c 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index f9fe22d1..a869af2d 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
-#Wed Sep 18 14:13:14 CEST 2019
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.3-all.zip
+#Wed Jan 29 14:26:26 CET 2020
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index 83f2acfd..2fe81a7d 100755
--- a/gradlew
+++ b/gradlew
@@ -154,19 +154,19 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=$((i+1))
+        i=`expr $i + 1`
     done
     case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
@@ -175,14 +175,9 @@ save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }
-APP_ARGS=$(save "$@")
+APP_ARGS=`save "$@"`
 
 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
 exec "$JAVACMD" "$@"
diff --git a/integration-tests/build.gradle b/integration-tests/build.gradle
deleted file mode 100644
index 23d232d2..00000000
--- a/integration-tests/build.gradle
+++ /dev/null
@@ -1,7 +0,0 @@
-subprojects {
-    buildscript {
-        dependencies {
-            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        }
-    }
-}
\ No newline at end of file
diff --git a/integration-tests/build.gradle.kts b/integration-tests/build.gradle.kts
new file mode 100644
index 00000000..e69de29b
diff --git a/integration-tests/gradle-integration-tests/build.gradle b/integration-tests/gradle-integration-tests/build.gradle
deleted file mode 100644
index 70213d8b..00000000
--- a/integration-tests/gradle-integration-tests/build.gradle
+++ /dev/null
@@ -1,60 +0,0 @@
-apply plugin: 'kotlin'
-
-sourceCompatibility = 1.8
-
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
-    kotlinOptions {
-        freeCompilerArgs += "-Xjsr305=strict"
-        languageVersion = language_version
-        apiVersion = language_version
-        jvmTarget = "1.8"
-    }
-}
-
-configurations {
-    dokkaPlugin
-    dokkaFatJar
-    kotlinGradle
-}
-
-dependencies {
-
-    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')
-    dokkaFatJar project(path: ":runners:fatjar", configuration: 'shadow')
-
-    kotlinGradle "org.jetbrains.kotlin:kotlin-gradle-plugin"
-
-    testCompile group: 'junit', name: 'junit', version: '4.12'
-    testCompile gradleTestKit()
-}
-
-
-
-task createClasspathManifest {
-    def outputDir = file("$buildDir/$name")
-
-    inputs.files(configurations.dokkaPlugin + configurations.dokkaFatJar)
-    outputs.dir outputDir
-
-    doLast {
-        outputDir.mkdirs()
-        file("$outputDir/dokka-plugin-classpath.txt").text = configurations.dokkaPlugin.join("\n")
-        file("$outputDir/fatjar.txt").text = configurations.dokkaFatJar.join("\n")
-        file("$outputDir/kotlin-gradle.txt").text = configurations.kotlinGradle.join("\n")
-    }
-}
-
-
-createClasspathManifest.mustRunAfter project(":runners:fatjar").getTasksByName("shadowJar", true)
-testClasses.dependsOn project(":runners:fatjar").shadowJar
-testClasses.dependsOn createClasspathManifest
-
-test {
-    systemProperty "android.licenses.overwrite", project.findProperty("android.licenses.overwrite") ?: ""
-    inputs.dir(file('testData'))
-    exclude '*' // TODO: Remove this exclude when tests are migrated
-}
\ No newline at end of file
diff --git a/integration-tests/gradle-integration-tests/build.gradle.kts b/integration-tests/gradle-integration-tests/build.gradle.kts
new file mode 100644
index 00000000..6a3fc690
--- /dev/null
+++ b/integration-tests/gradle-integration-tests/build.gradle.kts
@@ -0,0 +1,52 @@
+val dokkaPlugin by configurations.creating
+val dokkaCore by configurations.creating
+val kotlinGradle by configurations.creating
+
+dependencies {
+    val kotlin_version: String by project
+    testCompileOnly(group = "org.jetbrains.kotlin", name = "kotlin-stdlib", version = kotlin_version)
+    testImplementation(
+        group = "org.jetbrains.kotlin",
+        name = "kotlin-test-junit",
+        version = kotlin_version
+    )
+    testImplementation(project(":coreDependencies"))
+    dokkaPlugin(project(path = ":runners:gradle-plugin"))
+    dokkaCore(project(path = ":core", configuration = "shadow"))
+
+    kotlinGradle("org.jetbrains.kotlin:kotlin-gradle-plugin")
+
+    testImplementation(group = "junit", name = "junit", version = "4.13")
+    testImplementation(gradleTestKit())
+}
+
+
+val createClasspathManifest by tasks.registering {
+    dependsOn(project(":core").getTasksByName("shadowJar", true))
+
+    val outputDir = file("$buildDir/$name")
+    inputs.files(dokkaPlugin + dokkaCore)
+    outputs.dir(outputDir)
+
+    doLast {
+        outputDir.mkdirs()
+        file("$outputDir/dokka-plugin-classpath.txt").writeText(dokkaPlugin.joinToString("\n"))
+        file("$outputDir/fatjar.txt").writeText(dokkaCore.joinToString("\n"))
+        file("$outputDir/kotlin-gradle.txt").writeText(kotlinGradle.joinToString("\n"))
+    }
+}
+
+val testClasses by tasks.getting
+
+testClasses.dependsOn(project(":core").getTasksByName("shadowJar", true))
+testClasses.dependsOn(createClasspathManifest)
+
+tasks {
+    test {
+        systemProperty("android.licenses.overwrite", project.findProperty("android.licenses.overwrite") ?: "")
+        inputs.dir(file("testData"))
+        exclude("*") // TODO: Remove this exclude when tests are migrated
+    }
+}
+
+// TODO: see if this file makes any sense
\ No newline at end of file
diff --git a/integration/build.gradle b/integration/build.gradle
deleted file mode 100644
index ce25d9bf..00000000
--- a/integration/build.gradle
+++ /dev/null
@@ -1,25 +0,0 @@
-buildscript {
-    repositories { jcenter() }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-
-sourceCompatibility = 1.8
-
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
-    kotlinOptions {
-        languageVersion = language_version
-        apiVersion = language_version
-        jvmTarget = "1.8"
-    }
-}
-
-dependencies {
-    compileOnly group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib', version: kotlin_for_gradle_runtime_version
-    compileOnly group: 'org.jetbrains.kotlin', name: 'kotlin-reflect', version: kotlin_for_gradle_runtime_version
-    implementation "com.google.code.gson:gson:$gson_version"
-}
\ No newline at end of file
diff --git a/integration/src/main/kotlin/org/jetbrains/dokka/DokkaBootstrap.kt b/integration/src/main/kotlin/org/jetbrains/dokka/DokkaBootstrap.kt
deleted file mode 100644
index b78eb9c6..00000000
--- a/integration/src/main/kotlin/org/jetbrains/dokka/DokkaBootstrap.kt
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.jetbrains.dokka
-
-import java.util.function.BiConsumer
-
-interface DokkaBootstrap {
-
-    fun configure(logger: BiConsumer<String, String>, serializedConfigurationJSON: String)
-
-    fun generate()
-}
\ No newline at end of file
diff --git a/integration/src/main/kotlin/org/jetbrains/dokka/ReflectDsl.kt b/integration/src/main/kotlin/org/jetbrains/dokka/ReflectDsl.kt
deleted file mode 100644
index 1984a3e5..00000000
--- a/integration/src/main/kotlin/org/jetbrains/dokka/ReflectDsl.kt
+++ /dev/null
@@ -1,72 +0,0 @@
-package org.jetbrains.dokka
-
-import kotlin.reflect.*
-import kotlin.reflect.full.memberFunctions
-import kotlin.reflect.full.memberProperties
-import kotlin.reflect.jvm.isAccessible
-
-object ReflectDsl {
-
-    class CallOrPropAccess(private val receiver: Any?,
-                           private val clz: KClass<*>,
-                           private val selector: String) {
-
-        @Suppress("UNCHECKED_CAST")
-        operator fun <T : Any?> invoke(vararg a: Any?): T {
-            return func!!.call(receiver, *a) as T
-        }
-
-        operator fun get(s: String): CallOrPropAccess {
-            return v<Any?>()!![s]
-        }
-
-        val func: KFunction<*>? by lazy { clz.memberFunctions.find { it.name == selector } }
-        val prop: KProperty<*>? by lazy { clz.memberProperties.find { it.name == selector } }
-
-        fun takeIfIsFunc(): CallOrPropAccess? = if (func != null) this else null
-
-        fun takeIfIsProp(): CallOrPropAccess? = if (prop != null) this else null
-
-        @Suppress("UNCHECKED_CAST")
-        fun <T : Any?> v(): T {
-            val prop = prop!!
-            return try {
-                prop.getter.apply { isAccessible = true }.call(receiver) as T
-            } catch (e: KotlinNullPointerException) {
-                // Hack around kotlin-reflect bug KT-18480
-                val jclass = clz.java
-                val customGetterName = prop.getter.name
-                val getterName = if (customGetterName.startsWith("<")) "get" + prop.name.capitalize() else customGetterName
-                val getter = jclass.getDeclaredMethod(getterName)
-                getter.isAccessible = true
-
-                getter.invoke(receiver) as T
-
-            }
-        }
-
-        @Suppress("UNCHECKED_CAST")
-        fun v(x: Any?) {
-            (prop as KMutableProperty).setter.apply { isAccessible = true }.call(receiver, x)
-        }
-
-
-    }
-
-    operator fun Any.get(s: String): CallOrPropAccess {
-        val clz = this.javaClass.kotlin
-        return CallOrPropAccess(this, clz, s)
-    }
-
-    operator fun Any.get(s: String, clz: Class<*>): CallOrPropAccess {
-        val kclz = clz.kotlin
-        return CallOrPropAccess(this, kclz, s)
-    }
-
-    operator fun Any.get(s: String, clz: KClass<*>): CallOrPropAccess {
-        return CallOrPropAccess(this, clz, s)
-    }
-
-    inline infix fun Any.isInstance(clz: Class<*>?): Boolean = clz != null && clz.isAssignableFrom(this.javaClass)
-    inline infix fun Any.isNotInstance(clz: Class<*>?): Boolean = !(this isInstance clz)
-}
\ No newline at end of file
diff --git a/integration/src/main/kotlin/org/jetbrains/dokka/configuration.kt b/integration/src/main/kotlin/org/jetbrains/dokka/configuration.kt
deleted file mode 100644
index 8c6d35e8..00000000
--- a/integration/src/main/kotlin/org/jetbrains/dokka/configuration.kt
+++ /dev/null
@@ -1,98 +0,0 @@
-package org.jetbrains.dokka
-
-import java.io.File
-import java.net.URL
-
-enum class Platform(val key: String) {
-    jvm("jvm"),
-    js("js"),
-    native("native"),
-    common("common");
-
-    companion object {
-        val DEFAULT = jvm
-
-        fun fromString(key: String): Platform {
-            return when (key.toLowerCase()) {
-                jvm.key -> jvm
-                js.key -> js
-                native.key -> native
-                common.key -> common
-                else -> throw IllegalArgumentException("Unrecognized platform: $key")
-            }
-        }
-    }
-}
-
-interface DokkaConfiguration {
-    val outputDir: String
-    val format: String
-    val generateIndexPages: Boolean
-    val cacheRoot: String?
-    val passesConfigurations: List<PassConfiguration>
-    val impliedPlatforms: List<String>
-    var pluginsClasspath: List<File>
-
-    interface PassConfiguration {
-        val moduleName: String
-        val classpath: List<String>
-        val sourceRoots: List<SourceRoot>
-        val samples: List<String>
-        val includes: List<String>
-        val includeNonPublic: Boolean
-        val includeRootPackage: Boolean
-        val reportUndocumented: Boolean
-        val skipEmptyPackages: Boolean
-        val skipDeprecated: Boolean
-        val jdkVersion: Int
-        val sourceLinks: List<SourceLinkDefinition>
-        val perPackageOptions: List<PackageOptions>
-        val externalDocumentationLinks: List<ExternalDocumentationLink>
-        val languageVersion: String?
-        val apiVersion: String?
-        val noStdlibLink: Boolean
-        val noJdkLink: Boolean
-        val suppressedFiles: List<String>
-        val collectInheritedExtensionsFromLibraries: Boolean
-        val analysisPlatform: Platform
-        val targets: List<String>
-        val sinceKotlin: String?
-    }
-
-    interface SourceRoot {
-        val path: String
-    }
-
-    interface SourceLinkDefinition {
-        val path: String
-        val url: String
-        val lineSuffix: String?
-    }
-
-    interface PackageOptions {
-        val prefix: String
-        val includeNonPublic: Boolean
-        val reportUndocumented: Boolean
-        val skipDeprecated: Boolean
-        val suppress: Boolean
-    }
-
-    interface ExternalDocumentationLink {
-        val url: URL
-        val packageListUrl: URL
-
-        open class Builder(open var url: URL? = null,
-                           open var packageListUrl: URL? = null) {
-
-            constructor(root: String, packageList: String? = null) : this(URL(root), packageList?.let { URL(it) })
-
-            fun build(): ExternalDocumentationLink =
-                if (packageListUrl != null && url != null)
-                    ExternalDocumentationLinkImpl(url!!, packageListUrl!!)
-                else if (url != null)
-                    ExternalDocumentationLinkImpl(url!!, URL(url!!, "package-list"))
-                else
-                    throw IllegalArgumentException("url or url && packageListUrl must not be null for external documentation link")
-        }
-    }
-}
diff --git a/integration/src/main/kotlin/org/jetbrains/dokka/defaultConfiguration.kt b/integration/src/main/kotlin/org/jetbrains/dokka/defaultConfiguration.kt
deleted file mode 100644
index 6c797fcd..00000000
--- a/integration/src/main/kotlin/org/jetbrains/dokka/defaultConfiguration.kt
+++ /dev/null
@@ -1,74 +0,0 @@
-package org.jetbrains.dokka
-
-import java.io.File
-import java.net.URL
-
-data class DokkaConfigurationImpl(
-    override val outputDir: String,
-    override val format: String,
-    override val generateIndexPages: Boolean,
-    override val cacheRoot: String?,
-    override val impliedPlatforms: List<String>,
-    override val passesConfigurations: List<PassConfigurationImpl>,
-    override var pluginsClasspath: List<File>
-) : DokkaConfiguration
-
-data class PassConfigurationImpl (
-    override val moduleName: String,
-    override val classpath: List<String>,
-    override val sourceRoots: List<SourceRootImpl>,
-    override val samples: List<String>,
-    override val includes: List<String>,
-    override val includeNonPublic: Boolean,
-    override val includeRootPackage: Boolean,
-    override val reportUndocumented: Boolean,
-    override val skipEmptyPackages: Boolean,
-    override val skipDeprecated: Boolean,
-    override val jdkVersion: Int,
-    override val sourceLinks: List<SourceLinkDefinitionImpl>,
-    override val perPackageOptions: List<PackageOptionsImpl>,
-    override var externalDocumentationLinks: List<ExternalDocumentationLinkImpl>,
-    override val languageVersion: String?,
-    override val apiVersion: String?,
-    override val noStdlibLink: Boolean,
-    override val noJdkLink: Boolean,
-    override val suppressedFiles: List<String>,
-    override val collectInheritedExtensionsFromLibraries: Boolean,
-    override val analysisPlatform: Platform,
-    override val targets: List<String>,
-    override val sinceKotlin: String?
-) : DokkaConfiguration.PassConfiguration
-
-
-data class SourceRootImpl(
-    override val path: String
-): DokkaConfiguration.SourceRoot
-
-data class SourceLinkDefinitionImpl(
-    override val path: String,
-    override val url: String,
-    override val lineSuffix: String?
-): DokkaConfiguration.SourceLinkDefinition {
-    companion object {
-        fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinitionImpl {
-            val (path, urlAndLine) = srcLink.split('=')
-            return SourceLinkDefinitionImpl(
-                File(path).canonicalPath,
-                urlAndLine.substringBefore("#"),
-                urlAndLine.substringAfter("#", "").let { if (it.isEmpty()) null else "#$it" })
-        }
-    }
-}
-
-data class PackageOptionsImpl(
-    override val prefix: String,
-    override val includeNonPublic: Boolean,
-    override val reportUndocumented: Boolean,
-    override val skipDeprecated: Boolean,
-    override val suppress: Boolean
-): DokkaConfiguration.PackageOptions
-
-
-data class ExternalDocumentationLinkImpl(override val url: URL,
-                                         override val packageListUrl: URL
-) : DokkaConfiguration.ExternalDocumentationLink
\ No newline at end of file
diff --git a/plugins/build.gradle b/plugins/build.gradle
deleted file mode 100644
index a0bc5ee1..00000000
--- a/plugins/build.gradle
+++ /dev/null
@@ -1,25 +0,0 @@
-buildscript {
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-allprojects {
-    apply plugin: 'kotlin'
-
-    sourceCompatibility = 1.8
-
-    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
-        kotlinOptions {
-            languageVersion = language_version
-            apiVersion = language_version
-            jvmTarget = "1.8"
-        }
-    }
-}
-
-subprojects {
-    dependencies {
-        testCompile project(':testApi')
-    }
-}
\ No newline at end of file
diff --git a/plugins/build.gradle.kts b/plugins/build.gradle.kts
new file mode 100644
index 00000000..5f2f6dcb
--- /dev/null
+++ b/plugins/build.gradle.kts
@@ -0,0 +1,11 @@
+subprojects {
+    apply {
+        plugin("maven-publish")
+    }
+
+    dependencies {
+        compileOnly(project(":core"))
+        compileOnly(kotlin("stdlib-jdk8"))
+        testImplementation(project(":testApi"))
+    }
+}
\ No newline at end of file
diff --git a/plugins/mathjax/build.gradle b/plugins/mathjax/build.gradle
deleted file mode 100644
index 6578ff45..00000000
--- a/plugins/mathjax/build.gradle
+++ /dev/null
@@ -1,17 +0,0 @@
-import javax.tools.ToolProvider
-
-apply plugin: 'maven-publish'
-
-dependencies {
-    compileOnly project(':core')
-}
-
-publishing {
-    publications {
-        dokkaCore(MavenPublication) { publication ->
-            artifactId = 'mathjax-plugin'
-
-            from components.java
-        }
-    }
-}
\ No newline at end of file
diff --git a/plugins/mathjax/build.gradle.kts b/plugins/mathjax/build.gradle.kts
new file mode 100644
index 00000000..0e9a16d0
--- /dev/null
+++ b/plugins/mathjax/build.gradle.kts
@@ -0,0 +1,8 @@
+publishing {
+    publications {
+        register<MavenPublication>("mathjaxPlugin") {
+            artifactId = "mathjax-plugin"
+            from(components["java"])
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/xml/build.gradle b/plugins/xml/build.gradle
deleted file mode 100644
index ed4adb92..00000000
--- a/plugins/xml/build.gradle
+++ /dev/null
@@ -1,17 +0,0 @@
-import javax.tools.ToolProvider
-
-apply plugin: 'maven-publish'
-
-dependencies {
-    compileOnly project(':core')
-}
-
-publishing {
-    publications {
-        dokkaCore(MavenPublication) { publication ->
-            artifactId = 'xml-plugin'
-
-            from components.java
-        }
-    }
-}
\ No newline at end of file
diff --git a/plugins/xml/build.gradle.kts b/plugins/xml/build.gradle.kts
new file mode 100644
index 00000000..cd65cfe4
--- /dev/null
+++ b/plugins/xml/build.gradle.kts
@@ -0,0 +1,8 @@
+publishing {
+    publications {
+        register<MavenPublication>("xmlPlugin") {
+            artifactId = "xml-plugin"
+            from(components["java"])
+        }
+    }
+}
\ No newline at end of file
diff --git a/runners/build.gradle b/runners/build.gradle
deleted file mode 100644
index 23d232d2..00000000
--- a/runners/build.gradle
+++ /dev/null
@@ -1,7 +0,0 @@
-subprojects {
-    buildscript {
-        dependencies {
-            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        }
-    }
-}
\ No newline at end of file
diff --git a/runners/build.gradle.kts b/runners/build.gradle.kts
new file mode 100644
index 00000000..57081149
--- /dev/null
+++ b/runners/build.gradle.kts
@@ -0,0 +1,6 @@
+subprojects {
+    apply {
+        plugin("maven-publish")
+        plugin("com.jfrog.bintray")
+    }
+}
\ No newline at end of file
diff --git a/runners/cli/build.gradle b/runners/cli/build.gradle
deleted file mode 100644
index 24db0b1e..00000000
--- a/runners/cli/build.gradle
+++ /dev/null
@@ -1,16 +0,0 @@
-apply plugin: 'kotlin'
-
-sourceCompatibility = 1.8
-
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
-    kotlinOptions {
-        languageVersion = language_version
-        apiVersion = language_version
-        jvmTarget = "1.8"
-    }
-}
-
-dependencies {
-    implementation "org.jetbrains.kotlinx:kotlinx-cli-jvm:0.1.0-dev-3"
-    implementation project(":core")
-}
diff --git a/runners/cli/build.gradle.kts b/runners/cli/build.gradle.kts
new file mode 100644
index 00000000..4b39d64c
--- /dev/null
+++ b/runners/cli/build.gradle.kts
@@ -0,0 +1,37 @@
+import org.jetbrains.configureBintrayPublication
+
+plugins {
+    id("com.github.johnrengelman.shadow")
+}
+
+repositories {
+    maven(url = "https://dl.bintray.com/orangy/maven")
+}
+
+dependencies {
+    implementation("org.jetbrains.kotlinx:kotlinx-cli-jvm:0.1.0-dev-3")
+    implementation(project(":core"))
+}
+
+
+tasks {
+    shadowJar {
+        val dokka_version: String by project
+        archiveFileName.set("dokka-cli-$dokka_version.jar")
+        archiveClassifier.set("")
+        manifest {
+            attributes("Main-Class" to "org.jetbrains.dokka.MainKt")
+        }
+    }
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("dokkaCli") {
+            artifactId = "dokka-cli"
+            project.shadow.component(this)
+        }
+    }
+}
+
+configureBintrayPublication("dokkaCli")
\ No newline at end of file
diff --git a/runners/fatjar/build.gradle b/runners/fatjar/build.gradle
deleted file mode 100644
index cab64c0f..00000000
--- a/runners/fatjar/build.gradle
+++ /dev/null
@@ -1,78 +0,0 @@
-import com.github.jengelman.gradle.plugins.shadow.transformers.ServiceFileTransformer
-import org.jetbrains.PluginXmlTransformer
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-
-apply plugin: 'java'
-apply plugin: 'com.github.johnrengelman.shadow'
-
-dependencies {
-    compile project(":runners:cli")
-    compile project(":runners:ant")
-}
-
-jar {
-    manifest {
-        attributes 'Main-Class': 'org.jetbrains.dokka.MainKt'
-    }
-}
-
-shadowJar {
-    baseName = 'dokka-fatjar'
-    classifier = ''
-    configurations {
-        exclude compileOnly
-    }
-
-    transform(ServiceFileTransformer)
-    transform(PluginXmlTransformer)
-
-    exclude 'colorScheme/**'
-    exclude 'fileTemplates/**'
-    exclude 'inspectionDescriptions/**'
-    exclude 'intentionDescriptions/**'
-
-    exclude 'src/**'
-
-//    relocate('kotlin.reflect.full', 'kotlin.reflect')
-}
-
-task apiShadow(type: ShadowJar) {
-    baseName = 'dokka-fatapi'
-    classifier = ''
-
-    configurations = [project.configurations.compile]
-    configurations {
-        exclude compileOnly
-    }
-
-    transform(ServiceFileTransformer)
-    transform(PluginXmlTransformer)
-
-    exclude 'kotlin/**'
-    exclude 'colorScheme/**'
-    exclude 'fileTemplates/**'
-    exclude 'inspectionDescriptions/**'
-    exclude 'intentionDescriptions/**'
-
-    exclude 'src/**'
-
-//    relocate('kotlin.reflect.full', 'kotlin.reflect')
-}
-
-apply plugin: 'maven-publish'
-
-publishing {
-    publications {
-        dokkaFatJar(MavenPublication) { publication ->
-            artifactId = 'dokka-fatjar'
-            project.shadow.component(publication)
-        }
-
-        dokkaFatApi(MavenPublication) {publication ->
-            artifactId = 'dokka-fatapi'
-            publication.artifact(project.tasks.apiShadow)
-        }
-    }
-}
-
-bintrayPublication(project, ["dokkaFatJar"])
\ No newline at end of file
diff --git a/runners/gradle-plugin/build.gradle b/runners/gradle-plugin/build.gradle
deleted file mode 100644
index ceb03bae..00000000
--- a/runners/gradle-plugin/build.gradle
+++ /dev/null
@@ -1,108 +0,0 @@
-import com.gradle.publish.DependenciesBuilder
-
-apply plugin: 'java'
-apply plugin: 'kotlin'
-
-
-apply plugin: 'com.github.johnrengelman.shadow'
-apply plugin: "com.gradle.plugin-publish"
-
-sourceCompatibility = 1.8
-
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
-    kotlinOptions {
-        freeCompilerArgs += "-Xjsr305=strict"
-        languageVersion = language_version
-        apiVersion = language_version
-        jvmTarget = "1.8"
-    }
-}
-
-repositories {
-    jcenter()
-    google()
-}
-
-dependencies {
-    testCompile group: 'junit', name: 'junit', version: '4.12'
-
-    shadow group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib', version: kotlin_for_gradle_runtime_version
-    shadow group: 'org.jetbrains.kotlin', name: 'kotlin-reflect', version: kotlin_for_gradle_runtime_version
-
-    compile project(":integration")
-
-    compileOnly "org.jetbrains.kotlin:kotlin-gradle-plugin"
-    compileOnly("com.android.tools.build:gradle:3.0.0")
-    compileOnly("com.android.tools.build:gradle-core:3.0.0")
-    compileOnly("com.android.tools.build:builder-model:3.0.0")
-    compileOnly gradleApi()
-    compileOnly localGroovy()
-    implementation "com.google.code.gson:gson:$gson_version"
-}
-
-task sourceJar(type: Jar) {
-    from sourceSets.main.allSource
-}
-
-processResources {
-    eachFile {
-        if (it.name == "org.jetbrains.dokka.properties") {
-            it.filter { line ->
-                line.replace("<version>", dokka_version)
-            }
-        }
-    }
-}
-
-shadowJar {
-    baseName = 'dokka-gradle-plugin'
-    classifier = ''
-}
-
-apply plugin: 'maven-publish'
-
-publishing {
-    publications {
-        dokkaGradlePlugin(MavenPublication) { publication ->
-            artifactId = 'dokka-gradle-plugin'
-
-            artifact sourceJar {
-                classifier "sources"
-            }
-
-            project.shadow.component(publication)
-        }
-    }
-}
-
-bintrayPublication(project, ['dokkaGradlePlugin'])
-
-configurations.archives.artifacts.clear()
-artifacts {
-    archives shadowJar
-}
-
-pluginBundle {
-    website = 'https://www.kotlinlang.org/'
-    vcsUrl = 'https://github.com/kotlin/dokka.git'
-    description = 'Dokka, the Kotlin documentation tool'
-    tags = ['dokka', 'kotlin', 'kdoc', 'android']
-
-    plugins {
-        dokkaGradlePlugin {
-            id = 'org.jetbrains.dokka'
-            displayName = 'Dokka plugin'
-        }
-    }
-
-    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"
-    }
-}
\ No newline at end of file
diff --git a/runners/gradle-plugin/build.gradle.kts b/runners/gradle-plugin/build.gradle.kts
new file mode 100644
index 00000000..0d68a525
--- /dev/null
+++ b/runners/gradle-plugin/build.gradle.kts
@@ -0,0 +1,74 @@
+import org.jetbrains.configureBintrayPublication
+
+plugins {
+    id("com.gradle.plugin-publish")
+}
+
+repositories {
+    google()
+}
+
+dependencies {
+    implementation(project(":core"))
+    compileOnly("org.jetbrains.kotlin:kotlin-gradle-plugin")
+    compileOnly("com.android.tools.build:gradle:3.0.0")
+    compileOnly("com.android.tools.build:gradle-core:3.0.0")
+    compileOnly("com.android.tools.build:builder-model:3.0.0")
+    compileOnly(gradleApi())
+    constraints {
+        val kotlin_version: String by project
+        compileOnly("org.jetbrains.kotlin:kotlin-reflect:${kotlin_version}") {
+            because("kotlin-gradle-plugin and :core both depend on this")
+        }
+    }
+}
+
+tasks {
+    processResources {
+        val dokka_version: String by project
+        eachFile {
+            if (name == "org.jetbrains.dokka.properties") {
+                filter { line ->
+                    line.replace("<version>", dokka_version)
+                }
+            }
+        }
+    }
+}
+
+val sourceJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets["main"].allSource)
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("dokkaGradlePlugin") {
+            artifactId = "dokka-gradle-plugin"
+            from(components["java"])
+            artifact(sourceJar.get())
+        }
+    }
+}
+
+configureBintrayPublication("dokkaGradlePlugin") // TODO check if this publishes correctly
+
+pluginBundle {
+    // TODO check if this publishes correctly
+    website = "https://www.kotlinlang.org/"
+    vcsUrl = "https://github.com/kotlin/dokka.git"
+    description = "Dokka, the Kotlin documentation tool"
+    tags = listOf("dokka", "kotlin", "kdoc", "android")
+
+    plugins {
+        create("dokkaGradlePlugin") {
+            id = "org.jetbrains.dokka"
+            displayName = "Dokka plugin"
+        }
+    }
+
+    mavenCoordinates {
+        groupId = "org.jetbrains.dokka"
+        artifactId = "dokka-gradle-plugin"
+    }
+}
\ No newline at end of file
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 940c496e..65b0f4b3 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
@@ -89,17 +89,9 @@ open class DokkaTask : DefaultTask() {
 
     private var outputDiagnosticInfo: Boolean = false // Workaround for Gradle, which fires some methods (like collectConfigurations()) multiple times in its lifecycle
 
-    private fun tryResolveFatJar(configuration: Configuration?): Set<File> {
-        return try {
-            configuration!!.resolve()
-        } catch (e: Exception) {
-            project.parent?.let { tryResolveFatJar(configuration) } ?: throw e
-        }
-    }
-
     private fun loadFatJar() {
         if (ClassloaderContainer.fatJarClassLoader == null) {
-            val jars = tryResolveFatJar(dokkaRuntime).toList()
+            val jars = dokkaRuntime!!.resolve()
             ClassloaderContainer.fatJarClassLoader = URLClassLoader(jars.map { it.toURI().toURL() }.toTypedArray(), ClassLoader.getSystemClassLoader().parent)
         }
     }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ReflectDsl.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ReflectDsl.kt
new file mode 100644
index 00000000..1984a3e5
--- /dev/null
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ReflectDsl.kt
@@ -0,0 +1,72 @@
+package org.jetbrains.dokka
+
+import kotlin.reflect.*
+import kotlin.reflect.full.memberFunctions
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.isAccessible
+
+object ReflectDsl {
+
+    class CallOrPropAccess(private val receiver: Any?,
+                           private val clz: KClass<*>,
+                           private val selector: String) {
+
+        @Suppress("UNCHECKED_CAST")
+        operator fun <T : Any?> invoke(vararg a: Any?): T {
+            return func!!.call(receiver, *a) as T
+        }
+
+        operator fun get(s: String): CallOrPropAccess {
+            return v<Any?>()!![s]
+        }
+
+        val func: KFunction<*>? by lazy { clz.memberFunctions.find { it.name == selector } }
+        val prop: KProperty<*>? by lazy { clz.memberProperties.find { it.name == selector } }
+
+        fun takeIfIsFunc(): CallOrPropAccess? = if (func != null) this else null
+
+        fun takeIfIsProp(): CallOrPropAccess? = if (prop != null) this else null
+
+        @Suppress("UNCHECKED_CAST")
+        fun <T : Any?> v(): T {
+            val prop = prop!!
+            return try {
+                prop.getter.apply { isAccessible = true }.call(receiver) as T
+            } catch (e: KotlinNullPointerException) {
+                // Hack around kotlin-reflect bug KT-18480
+                val jclass = clz.java
+                val customGetterName = prop.getter.name
+                val getterName = if (customGetterName.startsWith("<")) "get" + prop.name.capitalize() else customGetterName
+                val getter = jclass.getDeclaredMethod(getterName)
+                getter.isAccessible = true
+
+                getter.invoke(receiver) as T
+
+            }
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        fun v(x: Any?) {
+            (prop as KMutableProperty).setter.apply { isAccessible = true }.call(receiver, x)
+        }
+
+
+    }
+
+    operator fun Any.get(s: String): CallOrPropAccess {
+        val clz = this.javaClass.kotlin
+        return CallOrPropAccess(this, clz, s)
+    }
+
+    operator fun Any.get(s: String, clz: Class<*>): CallOrPropAccess {
+        val kclz = clz.kotlin
+        return CallOrPropAccess(this, kclz, s)
+    }
+
+    operator fun Any.get(s: String, clz: KClass<*>): CallOrPropAccess {
+        return CallOrPropAccess(this, clz, s)
+    }
+
+    inline infix fun Any.isInstance(clz: Class<*>?): Boolean = clz != null && clz.isAssignableFrom(this.javaClass)
+    inline infix fun Any.isNotInstance(clz: Class<*>?): Boolean = !(this isInstance clz)
+}
\ No newline at end of file
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
index d75d3b21..71a02843 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/main.kt
@@ -25,7 +25,7 @@ open class DokkaPlugin : Plugin<Project> {
 
     private fun addConfiguration(project: Project) =
         project.configurations.create("dokkaRuntime").apply {
-            defaultDependencies{ dependencies -> dependencies.add(project.dependencies.create("org.jetbrains.dokka:dokka-fatjar:${DokkaVersion.version}")) }
+            defaultDependencies{ dependencies -> dependencies.add(project.dependencies.create("org.jetbrains.dokka:dokka-core:${DokkaVersion.version}")) }
         }
 
     private fun addTasks(
diff --git a/runners/maven-plugin/build.gradle b/runners/maven-plugin/build.gradle
deleted file mode 100644
index 76fab68d..00000000
--- a/runners/maven-plugin/build.gradle
+++ /dev/null
@@ -1,161 +0,0 @@
-import groovy.io.FileType
-import org.jetbrains.CorrectShadowPublishing
-import org.jetbrains.CrossPlatformExec
-
-import java.nio.file.Files
-import java.nio.file.StandardCopyOption
-
-apply plugin: 'kotlin'
-apply plugin: 'com.github.johnrengelman.shadow'
-
-sourceCompatibility = 1.8
-
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
-    kotlinOptions {
-        freeCompilerArgs += "-Xjsr305=strict"
-        languageVersion = "1.2"
-        apiVersion = languageVersion
-        jvmTarget = "1.8"
-    }
-}
-
-configurations {
-    maven
-}
-
-dependencies {
-    maven group: "org.apache.maven", name: 'apache-maven', version: maven_version, classifier: 'bin', ext: 'zip'
-
-    shadow project(":runners:fatjar")
-    shadow "org.apache.maven:maven-core:$maven_version"
-    shadow "org.apache.maven:maven-model:$maven_version"
-    shadow "org.apache.maven:maven-plugin-api:$maven_version"
-    shadow "org.apache.maven:maven-archiver:$maven_archiver_version"
-    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"
-}
-
-final File mavenHome = new File(buildDir, "maven-bin")
-final File mvn = new File(mavenHome, "apache-maven-$maven_version/bin/mvn")
-
-tasks.clean.doLast {
-    delete mavenHome
-}
-
-task setupMaven(type: Sync) {
-    from configurations.maven.collect{ zipTree(it) }
-    into "$buildDir/maven-bin"
-}
-
-def mavenBuildDir = "$buildDir/maven"
-
-
-sourceSets.main.resources {
-    srcDirs += "$mavenBuildDir/classes/java/main"
-    exclude "**/*.class"
-}
-
-task generatePom() {
-    inputs.file(new File(projectDir, "pom.tpl.xml"))
-    outputs.file(new File(mavenBuildDir, "pom.xml"))
-    doLast {
-        final pomTemplate = new File(projectDir, "pom.tpl.xml")
-        final pom = new File(mavenBuildDir, "pom.xml")
-        pom.parentFile.mkdirs()
-        pom.text = pomTemplate.text.replace("<version>dokka_version</version>", "<version>$dokka_version</version>")
-                .replace("<maven.version></maven.version>", "<maven.version>$maven_version</maven.version>")
-                .replace("<version>maven-plugin-plugin</version>", "<version>$maven_plugin_tools_version</version>")
-    }
-}
-//
-//task mergeClassOutputs doLast {
-//    def sourceDir = new File(buildDir, "classes/kotlin")
-//    def targetDir = new File(buildDir, "classes/java")
-//
-//    sourceDir.eachFileRecurse FileType.ANY, {
-//        def filePath = it.toPath()
-//        def targetFilePath = targetDir.toPath().resolve(sourceDir.toPath().relativize(filePath))
-//        if (it.isFile()) {
-//            Files.move(filePath, targetFilePath, StandardCopyOption.REPLACE_EXISTING)
-//        } else if (it.isDirectory()) {
-//            targetFilePath.toFile().mkdirs()
-//        }
-//    }
-//}
-
-
-
-task syncKotlinClasses(type: Sync, dependsOn: compileKotlin) {
-    from "$buildDir/classes/kotlin"
-    into "$mavenBuildDir/classes/java"
-    
-    preserve {
-        include '**/*.class'
-    }
-}
-
-task syncJavaClasses(type: Sync, dependsOn: compileJava) {
-    from "$buildDir/classes/java"
-    into "$mavenBuildDir/classes/java"
-
-    preserve {
-        include '**/*.class'
-    }
-}
-
-task helpMojo(type: CrossPlatformExec, dependsOn: setupMaven) {
-    workingDir mavenBuildDir
-    commandLine mvn, '-e', '-B', 'org.apache.maven.plugins:maven-plugin-plugin:helpmojo'
-
-    dependsOn syncKotlinClasses
-}
-
-
-task pluginDescriptor(type: CrossPlatformExec, dependsOn: setupMaven) {
-    workingDir mavenBuildDir
-    commandLine mvn, '-e', '-B', 'org.apache.maven.plugins:maven-plugin-plugin:descriptor'
-
-    dependsOn syncJavaClasses
-}
-
-
-//mergeClassOutputs.dependsOn compileKotlin
-//helpMojo.dependsOn mergeClassOutputs
-helpMojo.dependsOn generatePom
-sourceSets.main.java.srcDir("$buildDir/maven/generated-sources/plugin")
-compileJava.dependsOn helpMojo
-processResources.dependsOn pluginDescriptor
-
-pluginDescriptor.dependsOn generatePom
-
-shadowJar {
-    baseName = 'dokka-maven-plugin'
-    classifier = ''
-}
-
-shadowJar.dependsOn pluginDescriptor
-
-
-task sourceJar(type: Jar) {
-    from sourceSets.main.allSource
-}
-
-apply plugin: 'maven-publish'
-
-publishing {
-    publications {
-        dokkaMavenPlugin(MavenPublication) { MavenPublication publication ->
-            artifactId = 'dokka-maven-plugin'
-
-            artifact sourceJar {
-                classifier "sources"
-            }
-
-            CorrectShadowPublishing.configure(publication, project)
-        }
-    }
-}
-
-bintrayPublication(project, ['dokkaMavenPlugin'])
diff --git a/runners/maven-plugin/build.gradle.kts b/runners/maven-plugin/build.gradle.kts
new file mode 100644
index 00000000..2dffd71c
--- /dev/null
+++ b/runners/maven-plugin/build.gradle.kts
@@ -0,0 +1,115 @@
+import org.jetbrains.configureBintrayPublication
+
+/**
+ * [mavenBin] configuration is used to download Maven Plugin Plugin
+ * for generating plugin-help.xml and plugin.xml files
+ */
+val mavenBin: Configuration by configurations.creating
+
+val maven_version: String by project
+
+dependencies {
+    implementation(project(":core"))
+    implementation("org.apache.maven:maven-core:$maven_version")
+    implementation("org.apache.maven:maven-plugin-api:$maven_version")
+    val maven_plugin_tools_version: String by project
+    implementation("org.apache.maven.plugin-tools:maven-plugin-annotations:$maven_plugin_tools_version")
+    val maven_archiver_version: String by project
+    implementation("org.apache.maven:maven-archiver:$maven_archiver_version")
+
+    mavenBin(group = "org.apache.maven", name = "apache-maven", version = maven_version, classifier = "bin", ext = "zip")
+    compileOnly(kotlin("stdlib-jdk8"))
+}
+
+val mavenBinDir = "$buildDir/maven-bin"
+val mavenBuildDir = "$buildDir/maven"
+val mvn = File(mavenBinDir, "apache-maven-$maven_version/bin/mvn")
+
+tasks.named<Delete>("clean") {
+    delete(mavenBinDir)
+}
+
+/**
+ * Copy Maven Plugin Plugin to [mavenBinDir] directory
+ */
+val setupMaven by tasks.registering(Sync::class) {
+    from(mavenBin.map { zipTree(it) })
+    into(mavenBinDir)
+}
+
+/**
+ * Generate pom.xml for Maven Plugin Plugin
+ */
+val generatePom by tasks.registering(Copy::class) {
+    val dokka_version: String by project
+    val maven_plugin_tools_version: String by project
+
+    from("$projectDir/pom.tpl.xml") {
+        rename("(.*).tpl.xml", "$1.xml")
+    }
+    into(mavenBuildDir)
+
+    eachFile {
+        filter { line ->
+            line.replace("<maven.version></maven.version>", "<maven.version>$maven_version</maven.version>")
+        }
+        filter { line ->
+            line.replace("<version>dokka_version</version>", "<version>$dokka_version</version>")
+        }
+        filter { line ->
+            line.replace("<version>maven-plugin-plugin</version>", "<version>$maven_plugin_tools_version</version>")
+        }
+    }
+}
+
+/**
+ * Copy compiled classes to [mavenBuildDir] for Maven Plugin Plugin
+ */
+val syncClasses by tasks.registering(Sync::class) {
+    dependsOn(tasks.compileKotlin, tasks.compileJava)
+    from("$buildDir/classes/kotlin", "$buildDir/classes/java")
+    into("$mavenBuildDir/classes/java")
+
+    preserve {
+        include("**/*.class")
+    }
+}
+
+val helpMojo by tasks.registering(org.jetbrains.CrossPlatformExec::class) {
+    dependsOn(setupMaven, generatePom, syncClasses)
+    workingDir(mavenBuildDir)
+    commandLine(mvn, "-e", "-B", "org.apache.maven.plugins:maven-plugin-plugin:helpmojo")
+}
+
+val pluginDescriptor by tasks.registering(org.jetbrains.CrossPlatformExec::class) {
+    dependsOn(setupMaven, generatePom, syncClasses)
+    workingDir(mavenBuildDir)
+    commandLine(mvn, "-e", "-B", "org.apache.maven.plugins:maven-plugin-plugin:descriptor")
+}
+
+val sourceJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets["main"].allSource)
+}
+
+tasks.named<Jar>("jar") {
+    dependsOn(pluginDescriptor, helpMojo)
+    metaInf {
+        from("$mavenBuildDir/classes/java/main/META-INF")
+    }
+    manifest {
+        attributes("Class-Path" to configurations.runtimeClasspath.get().files.joinToString(" ") { it.name })
+    }
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("dokkaMavenPlugin") {
+            artifactId = "dokka-maven-plugin"
+            from(components["java"])
+            artifact(sourceJar.get())
+        }
+    }
+}
+
+configureBintrayPublication("dokkaMavenPlugin")
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index fb11ecac..67188325 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -189,7 +189,8 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             impliedPlatforms = impliedPlatforms,
             cacheRoot = cacheRoot,
             passesConfigurations = listOf(passConfiguration),
-            generateIndexPages = generateIndexPages
+            generateIndexPages = generateIndexPages,
+            pluginsClasspath = emptyList() //TODO fix this
         )
 
         val gen = DokkaGenerator(configuration, MavenDokkaLogger(log))
diff --git a/runners/maven-plugin/src/main/kotlin/MavenDokkaLogger.kt b/runners/maven-plugin/src/main/kotlin/MavenDokkaLogger.kt
index a535c807..950af3e0 100644
--- a/runners/maven-plugin/src/main/kotlin/MavenDokkaLogger.kt
+++ b/runners/maven-plugin/src/main/kotlin/MavenDokkaLogger.kt
@@ -1,17 +1,21 @@
 package org.jetbrains.dokka.maven
 
 import org.apache.maven.plugin.logging.Log
-import org.jetbrains.dokka.DokkaLogger
+import org.jetbrains.dokka.utilities.DokkaLogger
 
 class MavenDokkaLogger(val log: Log) : DokkaLogger {
     override fun error(message: String) {
         log.error(message)
     }
 
+    override fun debug(message: String) = log.debug(message)
+
     override fun info(message: String) {
         log.info(message)
     }
 
+    override fun progress(message: String) = log.info(message)
+
     override fun warn(message: String) {
         log.warn(message)
     }
diff --git a/settings.gradle b/settings.gradle
deleted file mode 100644
index 323af4b9..00000000
--- a/settings.gradle
+++ /dev/null
@@ -1,16 +0,0 @@
-rootProject.name = "dokka"
-
-include 'core',
-//        'core:testApi',
-        'coreDependencies',
-        'integration',
-        'runners:gradle-integration-tests',
-        'runners:fatjar',
-        'runners:ant',
-        'runners:cli',
-//        'runners:maven-plugin',
-        'runners:gradle-plugin',
-//        'plugins:javadoc8'
-        'plugins:mathjax',
-        'plugins:xml',
-        'testApi'
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 00000000..364a96ad
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,29 @@
+rootProject.name = "dokka"
+
+include("core")
+include("coreDependencies")
+include("testApi")
+include("runners:gradle-plugin")
+include("runners:cli")
+include("runners:maven-plugin")
+include("plugins:xml")
+include("plugins:mathjax")
+//include("integration-tests:gradle-integration-tests")
+
+
+pluginManagement {
+    val kotlin_version: String by settings
+    plugins {
+        id("org.jetbrains.kotlin.jvm") version kotlin_version
+        id("com.github.johnrengelman.shadow") version "5.2.0"
+        id("com.jfrog.bintray") version "1.8.4"
+        id("com.gradle.plugin-publish") version "0.10.1"
+    }
+
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        jcenter()
+        gradlePluginPortal()
+    }
+}
\ No newline at end of file
diff --git a/testApi/build.gradle b/testApi/build.gradle
deleted file mode 100644
index 5425b7bc..00000000
--- a/testApi/build.gradle
+++ /dev/null
@@ -1,12 +0,0 @@
-buildscript {
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-apply plugin: 'kotlin'
-
-dependencies {
-    implementation project(':core')
-    implementation group: 'junit', name: 'junit', version: '4.12'
-    implementation group: 'org.jetbrains.kotlin', name: 'kotlin-test-junit', version: kotlin_version
-}
\ No newline at end of file
diff --git a/testApi/build.gradle.kts b/testApi/build.gradle.kts
new file mode 100644
index 00000000..db861b90
--- /dev/null
+++ b/testApi/build.gradle.kts
@@ -0,0 +1,29 @@
+import org.jetbrains.configureBintrayPublication
+
+plugins {
+    `maven-publish`
+    id("com.jfrog.bintray")
+}
+
+dependencies {
+    implementation(project(":core"))
+    implementation("junit:junit:4.13") // TODO: remove dependency to junit
+    implementation(kotlin("stdlib"))
+}
+
+val sourceJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets["main"].allSource)
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("dokkaTestAPI") {
+            artifactId = "dokka-test-api"
+            components["java"]
+            artifact(sourceJar.get())
+        }
+    }
+}
+
+configureBintrayPublication("dokkaTestAPI")
\ No newline at end of file
-- 
cgit 


From d6fab477e89b781c85cf123fa58078deaa15d480 Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Fri, 31 Jan 2020 11:09:20 +0100
Subject: Add official code style

---
 gradle.properties | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index 57ddc095..50aa8fd7 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -15,4 +15,6 @@ maven_archiver_version=2.5
 maven_plugin_tools_version=3.5.2
 
 # For CI
-mvn=mvn
\ No newline at end of file
+mvn=mvn
+
+kotlin.code.style=official
\ No newline at end of file
-- 
cgit 


From 79ec42607f3bc090ef40547a01aabcd1cd55886e Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Fri, 31 Jan 2020 14:04:42 +0100
Subject: Minor fixes, rewritten CrossPlatformExec.kt

---
 build.gradle.kts                                   | 13 ++--
 buildSrc/build.gradle.kts                          |  1 -
 .../groovy/org/jetbrains/CrossPlatformExec.groovy  | 84 ----------------------
 .../main/kotlin/org/jetbrains/BintrayPublishing.kt |  6 +-
 .../main/kotlin/org/jetbrains/CrossPlatformExec.kt | 67 +++++++++++++++++
 .../kotlin/org/jetbrains/DistMavenPublishing.kt    | 10 ++-
 gradle.properties                                  | 11 +--
 .../gradle-integration-tests/build.gradle.kts      | 36 ++++------
 runners/maven-plugin/build.gradle.kts              | 30 ++++----
 9 files changed, 108 insertions(+), 150 deletions(-)
 delete mode 100644 buildSrc/src/main/groovy/org/jetbrains/CrossPlatformExec.groovy
 create mode 100644 buildSrc/src/main/kotlin/org/jetbrains/CrossPlatformExec.kt

(limited to 'gradle.properties')

diff --git a/build.gradle.kts b/build.gradle.kts
index 5540184a..aab928e7 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,23 +1,22 @@
 import org.jetbrains.configureDistMaven
 import org.jetbrains.configureDokkaVersion
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     kotlin("jvm") apply false
     id("com.jfrog.bintray") apply false
 }
 
+val dokka_version: String by project
+
 allprojects {
     configureDokkaVersion()
-    val dokka_version: String by this
 
-    if (this == rootProject) {
-        println("Publication version: $dokka_version")
-    }
     group = "org.jetbrains.dokka"
     version = dokka_version
 
     val language_version: String by project
-    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class).all {
+    tasks.withType(KotlinCompile::class).all {
         kotlinOptions {
             freeCompilerArgs += "-Xjsr305=strict"
             languageVersion = language_version
@@ -40,4 +39,6 @@ subprojects {
     apply {
         plugin("org.jetbrains.kotlin.jvm")
     }
-}
\ No newline at end of file
+}
+
+println("Publication version: $dokka_version")
\ No newline at end of file
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
index aeec9540..7a7b8f6a 100644
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@@ -1,6 +1,5 @@
 plugins {
     `kotlin-dsl`
-    groovy
 }
 
 repositories {
diff --git a/buildSrc/src/main/groovy/org/jetbrains/CrossPlatformExec.groovy b/buildSrc/src/main/groovy/org/jetbrains/CrossPlatformExec.groovy
deleted file mode 100644
index d3973a8a..00000000
--- a/buildSrc/src/main/groovy/org/jetbrains/CrossPlatformExec.groovy
+++ /dev/null
@@ -1,84 +0,0 @@
-package org.jetbrains
-
-import org.gradle.api.tasks.AbstractExecTask
-import org.gradle.api.tasks.TaskAction
-import org.gradle.internal.os.OperatingSystem
-
-import java.nio.file.Files
-import java.nio.file.Path
-import java.nio.file.Paths
-
-class CrossPlatformExec extends AbstractExecTask {
-    private static final def windowsExtensions = ['bat', 'cmd', 'exe'];
-    private static final def unixExtensions = [null, 'sh'];
-
-    private boolean windows;
-
-    public CrossPlatformExec() {
-        super(CrossPlatformExec.class);
-        windows = OperatingSystem.current().windows;
-    }
-
-    @Override
-    @TaskAction
-    protected void exec() {
-        List<String> commandLine = this.getCommandLine();
-
-        if (!commandLine.isEmpty()) {
-            commandLine[0] = findCommand(commandLine[0], windows);
-        }
-
-        if (windows) {
-            if (!commandLine.isEmpty() && commandLine[0]) {
-                commandLine
-            }
-            commandLine.add(0, '/c');
-            commandLine.add(0, 'cmd');
-        }
-
-        this.setCommandLine(commandLine);
-
-        super.exec();
-    }
-
-    private static String findCommand(String command, boolean windows) {
-        command = normalizeCommandPaths(command);
-        def extensions = windows ? windowsExtensions : unixExtensions;
-
-        return extensions.findResult(command) { extension ->
-            Path commandFile
-            if (extension) {
-                commandFile = Paths.get(command + '.' + extension);
-            } else {
-                commandFile = Paths.get(command);
-            }
-
-            return resolveCommandFromFile(commandFile, windows);
-        };
-    }
-
-    private static String resolveCommandFromFile(Path commandFile, boolean windows) {
-        if (!Files.isExecutable(commandFile)) {
-            return null;
-        }
-        
-        return commandFile.toAbsolutePath().normalize();
-    }
-
-    private static String normalizeCommandPaths(String command) {
-        // need to escape backslash so it works with regex
-        String backslashSeparator = '\\\\';
-
-        String forwardSlashSeparator = '/';
-
-        // escape separator if it's a backslash
-        char backslash = '\\';
-        String separator = File.separatorChar == backslash ? backslashSeparator : File.separator
-
-        return command
-        // first replace all of the backslashes with forward slashes
-                .replaceAll(backslashSeparator, forwardSlashSeparator)
-        // then replace all forward slashes with whatever the separator actually is
-                .replaceAll(forwardSlashSeparator, separator);
-    }
-}
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/org/jetbrains/BintrayPublishing.kt b/buildSrc/src/main/kotlin/org/jetbrains/BintrayPublishing.kt
index 19e032a8..78e4257f 100644
--- a/buildSrc/src/main/kotlin/org/jetbrains/BintrayPublishing.kt
+++ b/buildSrc/src/main/kotlin/org/jetbrains/BintrayPublishing.kt
@@ -4,9 +4,7 @@ import com.jfrog.bintray.gradle.BintrayExtension
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.provideDelegate
 
-fun Project.configureBintrayPublication(publication: String) = configureBintrayPublication(listOf(publication))
-
-fun Project.configureBintrayPublication(publications: List<String>) {
+fun Project.configureBintrayPublication(vararg publications: String) {
     val dokka_version: String by this
     val dokka_publication_channel: String by this
     extensions.configure<BintrayExtension>("bintray") {
@@ -24,6 +22,6 @@ fun Project.configureBintrayPublication(publications: List<String>) {
                 name = dokka_version
             }
         }
-        setPublications(*publications.toTypedArray())
+        setPublications(*publications)
     }
 }
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/org/jetbrains/CrossPlatformExec.kt b/buildSrc/src/main/kotlin/org/jetbrains/CrossPlatformExec.kt
new file mode 100644
index 00000000..feb32cac
--- /dev/null
+++ b/buildSrc/src/main/kotlin/org/jetbrains/CrossPlatformExec.kt
@@ -0,0 +1,67 @@
+package org.jetbrains
+
+import org.gradle.api.tasks.AbstractExecTask
+import org.gradle.internal.os.OperatingSystem
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+
+open class CrossPlatformExec : AbstractExecTask<CrossPlatformExec>(CrossPlatformExec::class.java) {
+    private val windowsExtensions = listOf(".bat", ".cmd", ".exe")
+    private val unixExtensions = listOf("", ".sh")
+
+    private val isWindows = OperatingSystem.current().isWindows
+
+    override fun exec() {
+        val commandLine: MutableList<String> = this.commandLine
+
+        if (commandLine.isNotEmpty()) {
+            commandLine[0] = findCommand(commandLine[0])
+        }
+
+        if (isWindows) {
+            if (commandLine.isNotEmpty() && commandLine[0].isNotBlank()) {
+                commandLine
+            }
+            commandLine.add(0, "/c")
+            commandLine.add(0, "cmd")
+        }
+
+        this.commandLine = commandLine
+
+        super.exec()
+    }
+
+    private fun findCommand(command: String): String {
+        val command = normalizeCommandPaths(command)
+        val extensions = if (isWindows) windowsExtensions else unixExtensions
+
+        return extensions.map { extension ->
+            resolveCommandFromFile(Paths.get("$command$extension"))
+        }.firstOrNull() ?: command
+    }
+
+    private fun resolveCommandFromFile(commandFile: Path) =
+        if (!Files.isExecutable(commandFile)) {
+            ""
+        } else {
+            commandFile.toAbsolutePath().normalize().toString()
+        }
+
+
+    private fun normalizeCommandPaths(command: String): String {
+        // need to escape backslash so it works with regex
+        val backslashSeparator = "\\"
+        val forwardSlashSeparator = "/"
+
+        // get the actual separator
+        val separator = if (File.separatorChar == '\\') backslashSeparator else File.separator
+
+        return command
+            // first replace all of the backslashes with forward slashes
+            .replace(backslashSeparator, forwardSlashSeparator)
+            // then replace all forward slashes with whatever the separator actually is
+            .replace(forwardSlashSeparator, separator)
+    }
+}
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/org/jetbrains/DistMavenPublishing.kt b/buildSrc/src/main/kotlin/org/jetbrains/DistMavenPublishing.kt
index ec536bd7..175bbd0b 100644
--- a/buildSrc/src/main/kotlin/org/jetbrains/DistMavenPublishing.kt
+++ b/buildSrc/src/main/kotlin/org/jetbrains/DistMavenPublishing.kt
@@ -9,12 +9,10 @@ fun Project.configureDistMaven() { // TODO: This can probably be written cleaner
     val repoLocation = uri(file("${rootProject.buildDir}/dist-maven"))
     var distMaven: MavenArtifactRepository? = null
     pluginManager.withPlugin("maven-publish") {
-        this@configureDistMaven.extensions.findByType(PublishingExtension::class.java)?.let {
-            it.repositories {
-                distMaven = maven {
-                    name = "distMaven"
-                    url = repoLocation
-                }
+        this@configureDistMaven.extensions.findByType(PublishingExtension::class.java)?.repositories {
+            distMaven = maven {
+                name = "distMaven"
+                url = repoLocation
             }
         }
     }
diff --git a/gradle.properties b/gradle.properties
index 50aa8fd7..96dfefb5 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -7,14 +7,5 @@ kotlin_plugin_version=1.3.61-release-180
 idea_version=192.5728.98
 language_version=1.3
 
-ant_version=1.9.6
-
-# Maven plugin dependencies
-maven_version=3.5.0
-maven_archiver_version=2.5
-maven_plugin_tools_version=3.5.2
-
-# For CI
-mvn=mvn
-
+# Code style
 kotlin.code.style=official
\ No newline at end of file
diff --git a/integration-tests/gradle-integration-tests/build.gradle.kts b/integration-tests/gradle-integration-tests/build.gradle.kts
index d8b3cdc4..03dc2641 100644
--- a/integration-tests/gradle-integration-tests/build.gradle.kts
+++ b/integration-tests/gradle-integration-tests/build.gradle.kts
@@ -1,6 +1,6 @@
-val dokkaPlugin by configurations.creating
-val dokkaCore by configurations.creating
-val kotlinGradle by configurations.creating
+val dokkaPlugin: Configuration by configurations.creating
+val dokkaCore: Configuration by configurations.creating
+val kotlinGradle: Configuration by configurations.creating
 
 repositories {
     maven(url = "https://kotlin.bintray.com/kotlin-plugin")
@@ -8,26 +8,17 @@ repositories {
 
 dependencies {
     val kotlin_version: String by project
-    testCompileOnly(group = "org.jetbrains.kotlin", name = "kotlin-stdlib", version = kotlin_version)
-    testImplementation(
-        group = "org.jetbrains.kotlin",
-        name = "kotlin-test-junit",
-        version = kotlin_version
-    )
-    testImplementation(project(":coreDependencies"))
+    testCompileOnly("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
+    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version")
+    testImplementation("junit:junit:4.13")
+    testImplementation(gradleTestKit())
+
     dokkaPlugin(project(path = ":runners:gradle-plugin"))
     dokkaCore(project(path = ":core", configuration = "shadow"))
-
     kotlinGradle("org.jetbrains.kotlin:kotlin-gradle-plugin")
-
-    testImplementation(group = "junit", name = "junit", version = "4.13")
-    testImplementation(gradleTestKit())
 }
 
-
 val createClasspathManifest by tasks.registering {
-    dependsOn(project(":core").getTasksByName("shadowJar", true))
-
     val outputDir = file("$buildDir/$name")
     inputs.files(dokkaPlugin + dokkaCore)
     outputs.dir(outputDir)
@@ -40,15 +31,14 @@ val createClasspathManifest by tasks.registering {
     }
 }
 
-val testClasses by tasks.getting
-
-testClasses.dependsOn(project(":core").getTasksByName("shadowJar", true))
-testClasses.dependsOn(createClasspathManifest)
-
 tasks {
+    testClasses {
+        dependsOn(createClasspathManifest)
+    }
+
     test {
         systemProperty("android.licenses.overwrite", project.findProperty("android.licenses.overwrite") ?: "")
         inputs.dir(file("testData"))
-        exclude("*") // TODO: Remove this exclude when tests are migrated
+//        exclude("*") // TODO: Remove this exclude when tests are migrated
     }
 }
diff --git a/runners/maven-plugin/build.gradle.kts b/runners/maven-plugin/build.gradle.kts
index 2dffd71c..d97e7973 100644
--- a/runners/maven-plugin/build.gradle.kts
+++ b/runners/maven-plugin/build.gradle.kts
@@ -1,29 +1,28 @@
 import org.jetbrains.configureBintrayPublication
-
+import org.jetbrains.CrossPlatformExec
 /**
  * [mavenBin] configuration is used to download Maven Plugin Plugin
  * for generating plugin-help.xml and plugin.xml files
  */
 val mavenBin: Configuration by configurations.creating
 
-val maven_version: String by project
+val mavenVersion = "3.5.0"
+val mavenPluginToolsVersion = "3.5.2"
 
 dependencies {
     implementation(project(":core"))
-    implementation("org.apache.maven:maven-core:$maven_version")
-    implementation("org.apache.maven:maven-plugin-api:$maven_version")
-    val maven_plugin_tools_version: String by project
-    implementation("org.apache.maven.plugin-tools:maven-plugin-annotations:$maven_plugin_tools_version")
-    val maven_archiver_version: String by project
-    implementation("org.apache.maven:maven-archiver:$maven_archiver_version")
-
-    mavenBin(group = "org.apache.maven", name = "apache-maven", version = maven_version, classifier = "bin", ext = "zip")
+    implementation("org.apache.maven:maven-core:$mavenVersion")
+    implementation("org.apache.maven:maven-plugin-api:$mavenVersion")
+    implementation("org.apache.maven.plugin-tools:maven-plugin-annotations:$mavenPluginToolsVersion")
+    implementation("org.apache.maven:maven-archiver:2.5")
     compileOnly(kotlin("stdlib-jdk8"))
+
+    mavenBin(group = "org.apache.maven", name = "apache-maven", version = mavenVersion, classifier = "bin", ext = "zip")
 }
 
 val mavenBinDir = "$buildDir/maven-bin"
 val mavenBuildDir = "$buildDir/maven"
-val mvn = File(mavenBinDir, "apache-maven-$maven_version/bin/mvn")
+val mvn = File(mavenBinDir, "apache-maven-$mavenVersion/bin/mvn")
 
 tasks.named<Delete>("clean") {
     delete(mavenBinDir)
@@ -42,7 +41,6 @@ val setupMaven by tasks.registering(Sync::class) {
  */
 val generatePom by tasks.registering(Copy::class) {
     val dokka_version: String by project
-    val maven_plugin_tools_version: String by project
 
     from("$projectDir/pom.tpl.xml") {
         rename("(.*).tpl.xml", "$1.xml")
@@ -51,13 +49,13 @@ val generatePom by tasks.registering(Copy::class) {
 
     eachFile {
         filter { line ->
-            line.replace("<maven.version></maven.version>", "<maven.version>$maven_version</maven.version>")
+            line.replace("<maven.version></maven.version>", "<maven.version>$mavenVersion</maven.version>")
         }
         filter { line ->
             line.replace("<version>dokka_version</version>", "<version>$dokka_version</version>")
         }
         filter { line ->
-            line.replace("<version>maven-plugin-plugin</version>", "<version>$maven_plugin_tools_version</version>")
+            line.replace("<version>maven-plugin-plugin</version>", "<version>$mavenPluginToolsVersion</version>")
         }
     }
 }
@@ -75,13 +73,13 @@ val syncClasses by tasks.registering(Sync::class) {
     }
 }
 
-val helpMojo by tasks.registering(org.jetbrains.CrossPlatformExec::class) {
+val helpMojo by tasks.registering(CrossPlatformExec::class) {
     dependsOn(setupMaven, generatePom, syncClasses)
     workingDir(mavenBuildDir)
     commandLine(mvn, "-e", "-B", "org.apache.maven.plugins:maven-plugin-plugin:helpmojo")
 }
 
-val pluginDescriptor by tasks.registering(org.jetbrains.CrossPlatformExec::class) {
+val pluginDescriptor by tasks.registering(CrossPlatformExec::class) {
     dependsOn(setupMaven, generatePom, syncClasses)
     workingDir(mavenBuildDir)
     commandLine(mvn, "-e", "-B", "org.apache.maven.plugins:maven-plugin-plugin:descriptor")
-- 
cgit 


From 57e6b6210f481dbe03cc01b954e30cb365dd2b2e Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Thu, 19 Mar 2020 11:09:07 +0100
Subject: Update to 1.4-M2, Native fails with an exception

---
 .idea/kotlinc.xml                                  |  7 ++---
 build.gradle.kts                                   |  3 +-
 .../main/kotlin/analysis/AnalysisEnvironment.kt    | 34 ++++++++++------------
 coreDependencies/build.gradle.kts                  |  1 +
 gradle.properties                                  |  8 ++---
 runners/cli/src/main/kotlin/cli/main.kt            | 12 ++++----
 settings.gradle.kts                                |  1 +
 7 files changed, 32 insertions(+), 34 deletions(-)

(limited to 'gradle.properties')

diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml
index 5a05248b..35cd5ac3 100644
--- a/.idea/kotlinc.xml
+++ b/.idea/kotlinc.xml
@@ -1,11 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="Kotlin2JsCompilerArguments">
-    <option name="sourceMapEmbedSources" />
-    <option name="sourceMapPrefix" />
-  </component>
   <component name="KotlinCommonCompilerArguments">
     <option name="apiVersion" value="1.3" />
     <option name="languageVersion" value="1.3" />
   </component>
+  <component name="KotlinCompilerSettings">
+    <option name="additionalArguments" value="-version -Xskip-metadata-version-check" />
+  </component>
 </project>
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
index aab928e7..0b3c0da8 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -18,7 +18,7 @@ allprojects {
     val language_version: String by project
     tasks.withType(KotlinCompile::class).all {
         kotlinOptions {
-            freeCompilerArgs += "-Xjsr305=strict"
+            freeCompilerArgs += "-Xjsr305=strict -Xskip-metadata-version-check"
             languageVersion = language_version
             apiVersion = language_version
             jvmTarget = "1.8"
@@ -30,6 +30,7 @@ allprojects {
         mavenCentral()
         mavenLocal()
         maven(url = "https://dl.bintray.com/jetbrains/markdown/")
+        maven(url = "https://dl.bintray.com/kotlin/kotlin-dev")
     }
 
     configureDistMaven()
diff --git a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
index 7ed55acf..fea3516c 100644
--- a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
+++ b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
-import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
+import org.jetbrains.kotlin.caches.resolve.JsResolverForModuleFactory
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.ContentRoot
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
@@ -46,13 +46,9 @@ import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.ide.konan.NativeLibraryInfo
 import org.jetbrains.kotlin.ide.konan.analyzer.NativeResolverForModuleFactory
-import org.jetbrains.kotlin.ide.konan.decompiler.KotlinNativeLoadingMetadataCache
-import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
-import org.jetbrains.kotlin.js.resolve.JsResolverForModuleFactory
 import org.jetbrains.kotlin.library.impl.createKotlinLibrary
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.name.Name
@@ -61,7 +57,6 @@ import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.js.JsPlatforms
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms.unspecifiedJvmPlatform
-import org.jetbrains.kotlin.platform.konan.KonanPlatforms
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
@@ -72,11 +67,17 @@ import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
 import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModuleFactory
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerServices
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
+import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
+import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
+import org.jetbrains.kotlin.descriptors.konan.KlibModuleOrigin
+import org.jetbrains.kotlin.ide.konan.NativeKlibLibraryInfo
+import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaClass
+import org.jetbrains.kotlin.platform.konan.NativePlatforms
 import java.io.File
 
 const val JAR_SEPARATOR = "!/"
@@ -123,7 +124,6 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
             ModuleManager::class.java, moduleManager
         )
 
-        Extensions.registerAreaClass("IDEA_MODULE", null)
         CoreApplicationEnvironment.registerExtensionPoint(
             Extensions.getRootArea(),
             OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java
@@ -159,7 +159,7 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         val targetPlatform = when (analysisPlatform) {
             Platform.js -> JsPlatforms.defaultJsPlatform
             Platform.common -> CommonPlatforms.defaultCommonPlatform
-            Platform.native -> KonanPlatforms.defaultKonanPlatform
+            Platform.native -> NativePlatforms.unspecifiedNativePlatform
             Platform.jvm -> JvmPlatforms.defaultJvmPlatform
         }
 
@@ -246,16 +246,16 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
     }
 
     private fun createNativeLibraryModuleInfo(libraryFile: File): LibraryModuleInfo {
-        val kotlinLibrary = createKotlinLibrary(org.jetbrains.kotlin.konan.file.File(libraryFile.absolutePath), false)
+        val kotlinLibrary = createKotlinLibrary(org.jetbrains.kotlin.konan.file.File(libraryFile.absolutePath), "",false)
         return object : LibraryModuleInfo {
             override val analyzerServices: PlatformDependentAnalyzerServices =
                 analysisPlatform.analyzerServices()
             override val name: Name = Name.special("<klib>")
-            override val platform: TargetPlatform = KonanPlatforms.defaultKonanPlatform
+            override val platform: TargetPlatform = NativePlatforms.unspecifiedNativePlatform
             override fun dependencies(): List<ModuleInfo> = listOf(this)
             override fun getLibraryRoots(): Collection<String> = listOf(libraryFile.absolutePath)
             override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>
-                get() = super.capabilities + (NativeLibraryInfo.NATIVE_LIBRARY_CAPABILITY to kotlinLibrary)
+                get() = super.capabilities + (KlibModuleOrigin.CAPABILITY to kotlinLibrary)
         }
     }
 
@@ -345,15 +345,11 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
                 descriptor: ModuleDescriptor,
                 moduleInfo: ModuleInfo
             ): ResolverForModule {
-                (ApplicationManager.getApplication() as MockApplication).addComponent(
-                    KotlinNativeLoadingMetadataCache::class.java,
-                    KotlinNativeLoadingMetadataCache()
-                )
 
                 return NativeResolverForModuleFactory(
                     PlatformAnalysisParameters.Empty,
                     CompilerEnvironment,
-                    KonanPlatforms.defaultKonanPlatform
+                    NativePlatforms.unspecifiedNativePlatform
                 ).createResolverForModule(
                     descriptor as ModuleDescriptorImpl,
                     projectContext.withModule(descriptor),
@@ -413,14 +409,14 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
                             addRoots(javaRoots, messageCollector)
                         }
                 }, {
-                    val file = (it as JavaClassImpl).psi.containingFile.virtualFile
+                    val file =  (it as? BinaryJavaClass)?.virtualFile ?: (it as JavaClassImpl).psi.containingFile.virtualFile
                     if (file in sourcesScope)
                         module
                     else
                         library
                 }),
                 CompilerEnvironment,
-                KonanPlatforms.defaultKonanPlatform
+                unspecifiedJvmPlatform
             ).createResolverForModule(
                 descriptor as ModuleDescriptorImpl,
                 projectContext.withModule(descriptor),
diff --git a/coreDependencies/build.gradle.kts b/coreDependencies/build.gradle.kts
index bd1d3a18..17a71c04 100644
--- a/coreDependencies/build.gradle.kts
+++ b/coreDependencies/build.gradle.kts
@@ -30,6 +30,7 @@ dependencies {
     implementation("org.jetbrains:markdown:0.1.41") {
         because("it's published only on bintray")
     }
+    implementation("org.jetbrains.kotlin:ide-common-ij193:$kotlin_plugin_version")
 }
 
 tasks {
diff --git a/gradle.properties b/gradle.properties
index 96dfefb5..2924c778 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,10 +2,10 @@ dokka_version_base=0.11.0
 dokka_publication_channel=dokka
 
 # Kotlin compiler and plugin
-kotlin_version=1.3.61
-kotlin_plugin_version=1.3.61-release-180
-idea_version=192.5728.98
-language_version=1.3
+kotlin_version=1.4-M2-eap-70
+kotlin_plugin_version=1.4-M2-eap-63
+idea_version=193.6494.35
+language_version=1.4
 
 # Code style
 kotlin.code.style=official
\ 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 607a58a7..f0d22aff 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -71,7 +71,7 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         "main"
     )
 
-    override val classpath: List<String> by parser.repeatableOption(
+    override val classpath: List<String> by parser.repeatableOption<String>(
         listOf("-classpath"),
         "Classpath for symbol resolution"
     )
@@ -86,12 +86,12 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         "Source file or directory (allows many paths separated by the system path separator)"
     ) { SourceRootImpl(it) }
 
-    override val samples: List<String> by parser.repeatableOption(
+    override val samples: List<String> by parser.repeatableOption<String>(
         listOf("-sample"),
         "Source root for samples"
     )
 
-    override val includes: List<String> by parser.repeatableOption(
+    override val includes: List<String> by parser.repeatableOption<String>(
         listOf("-include"),
         "Markdown files to load (allows many paths separated by the system path separator)"
     )
@@ -150,7 +150,7 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         "Disable documentation link to JDK"
     )
 
-    override val suppressedFiles: List<String> by parser.repeatableOption(
+    override val suppressedFiles: List<String> by parser.repeatableOption<String>(
         listOf("-suppressedFile"),
         ""
     )
@@ -173,7 +173,7 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         { Platform.DEFAULT }
     )
 
-    override val targets: List<String> by parser.repeatableOption(
+    override val targets: List<String> by parser.repeatableOption<String>(
         listOf("-target"),
         "Generation targets"
     )
@@ -192,7 +192,7 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         { mutableListOf() }
     )
 
-    override val sourceLinks: MutableList<DokkaConfiguration.SourceLinkDefinition> by parser.repeatableOption(
+    override val sourceLinks: MutableList<DokkaConfiguration.SourceLinkDefinition> by parser.repeatableOption<DokkaConfiguration.SourceLinkDefinition>(
         listOf("-srcLink"),
         "Mapping between a source directory and a Web site for browsing the code"
     ) {
diff --git a/settings.gradle.kts b/settings.gradle.kts
index cc86f4fc..82bc8f5d 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -25,6 +25,7 @@ pluginManagement {
     }
 
     repositories {
+        maven(url="https://dl.bintray.com/kotlin/kotlin-dev/")
         mavenLocal()
         mavenCentral()
         jcenter()
-- 
cgit 


From a4ada10ddc48605dbd13e731c95f0375ad7af9b4 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Tue, 23 Jun 2020 07:55:07 +0200
Subject: Add dependency to coroutines

---
 gradle.properties             | 2 ++
 plugins/base/build.gradle.kts | 3 +++
 2 files changed, 5 insertions(+)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index 2924c778..5189c665 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -4,6 +4,8 @@ dokka_publication_channel=dokka
 # Kotlin compiler and plugin
 kotlin_version=1.4-M2-eap-70
 kotlin_plugin_version=1.4-M2-eap-63
+coroutines_version=1.3.7-1.4-M2
+
 idea_version=193.6494.35
 language_version=1.4
 
diff --git a/plugins/base/build.gradle.kts b/plugins/base/build.gradle.kts
index 97d6a646..b94a8ed3 100644
--- a/plugins/base/build.gradle.kts
+++ b/plugins/base/build.gradle.kts
@@ -5,6 +5,9 @@ plugins {
 }
 
 dependencies {
+    val coroutines_version: String by project
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version")
+
     api(project(":kotlin-analysis"))
     implementation("org.jsoup:jsoup:1.12.1")
     implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
-- 
cgit 


From 92ff5242c52f1d48ec70356a27557a3900a96694 Mon Sep 17 00:00:00 2001
From: Krzysztof Romanowski <romanowski.kr@gmail.com>
Date: Fri, 26 Jun 2020 11:09:51 +0200
Subject: Configure -Xmx in gradle properties

---
 gradle.properties | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index 5189c665..edd78940 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -10,4 +10,7 @@ idea_version=193.6494.35
 language_version=1.4
 
 # Code style
-kotlin.code.style=official
\ No newline at end of file
+kotlin.code.style=official
+
+# Memory settings
+org.gradle.jvmargs=-Xmx4g
-- 
cgit 


From 90459de7b6fce28a8ba57aca5eb213575204bc3d Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Mon, 15 Jun 2020 18:13:35 +0200
Subject: Update to Kotlin 1.4 M3

---
 gradle.properties                                                  | 6 +++---
 integration-tests/cli/build.gradle.kts                             | 7 ++++++-
 .../org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt | 1 -
 .../kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt     | 4 ++++
 .../kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt    | 7 ++-----
 plugins/base/build.gradle.kts                                      | 2 +-
 plugins/javadoc/build.gradle.kts                                   | 3 +++
 7 files changed, 19 insertions(+), 11 deletions(-)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index edd78940..f0c75c72 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,9 +2,9 @@ dokka_version_base=0.11.0
 dokka_publication_channel=dokka
 
 # Kotlin compiler and plugin
-kotlin_version=1.4-M2-eap-70
-kotlin_plugin_version=1.4-M2-eap-63
-coroutines_version=1.3.7-1.4-M2
+kotlin_version=1.4-M3-eap-197
+kotlin_plugin_version=1.4-M3-release-207
+coroutines_version=1.3.7-1.4-M3
 
 idea_version=193.6494.35
 language_version=1.4
diff --git a/integration-tests/cli/build.gradle.kts b/integration-tests/cli/build.gradle.kts
index f825a148..5fdf0ff5 100644
--- a/integration-tests/cli/build.gradle.kts
+++ b/integration-tests/cli/build.gradle.kts
@@ -19,7 +19,12 @@ dependencies {
 }
 
 /* Create a fat base plugin jar for cli tests */
-val basePluginShadow: Configuration by configurations.creating
+val basePluginShadow: Configuration by configurations.creating {
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage::class.java, "java-runtime"))
+    }
+}
+
 dependencies {
     basePluginShadow(project(":plugins:base"))
 }
diff --git a/integration-tests/gradle/src/main/kotlin/org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt b/integration-tests/gradle/src/main/kotlin/org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt
index f2dece62..2ba49a5a 100644
--- a/integration-tests/gradle/src/main/kotlin/org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt
+++ b/integration-tests/gradle/src/main/kotlin/org/jetbrains/dokka/it/gradle/AbstractGradleIntegrationTest.kt
@@ -42,4 +42,3 @@ abstract class AbstractGradleIntegrationTest : AbstractIntegrationTest() {
             .withJvmArguments("-Xmx4G", "-XX:MaxMetaspaceSize=1G")
     }
 }
-
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt
index 7836bde9..43bb9e48 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt
@@ -633,4 +633,8 @@ class DokkaResolutionFacade(
         throw UnsupportedOperationException()
     }
 
+    override fun getResolverForProject(): ResolverForProject<out ModuleInfo> {
+        throw UnsupportedOperationException()
+    }
+
 }
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt
index a12becee..d9a89194 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt
@@ -3,10 +3,7 @@ package org.jetbrains.dokka.analysis
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
+import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
@@ -42,7 +39,7 @@ class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector
 
     private var seenErrors = false
 
-    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) {
         if (severity == CompilerMessageSeverity.ERROR) {
             seenErrors = true
         }
diff --git a/plugins/base/build.gradle.kts b/plugins/base/build.gradle.kts
index cc34fce9..02babd4d 100644
--- a/plugins/base/build.gradle.kts
+++ b/plugins/base/build.gradle.kts
@@ -6,7 +6,7 @@ plugins {
 
 dependencies {
     val coroutines_version: String by project
-    // implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version") // TODO: Enable this dependency after update to 1.4-M3
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version")
 
     api(project(":kotlin-analysis"))
     implementation("org.jsoup:jsoup:1.12.1")
diff --git a/plugins/javadoc/build.gradle.kts b/plugins/javadoc/build.gradle.kts
index 1f39c3a1..4c5c22b0 100644
--- a/plugins/javadoc/build.gradle.kts
+++ b/plugins/javadoc/build.gradle.kts
@@ -15,6 +15,9 @@ dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
     implementation(project(":plugins:base"))
     implementation(project(":plugins:kotlin-as-java"))
+
+    val coroutines_version: String by project
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version")
 }
 
 configureBintrayPublication("javadocPlugin")
-- 
cgit 


From a23b652f7f1f43d4cdda4509ff7ff461a0d0bf3a Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Fri, 26 Jun 2020 00:49:08 +0200
Subject: Update version of dokka

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index f0c75c72..371b0b3f 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,4 +1,4 @@
-dokka_version_base=0.11.0
+dokka_version_base=1.4-M3
 dokka_publication_channel=dokka
 
 # Kotlin compiler and plugin
-- 
cgit 


From bed2450c8d6ddd5c1ef05e3e451443c286eddea1 Mon Sep 17 00:00:00 2001
From: Alex Saveau <asaveau@google.com>
Date: Thu, 9 Jul 2020 08:17:26 +0000
Subject: Run build in parallel with Gradle cache

---
 gradle.properties | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index 371b0b3f..3d00dff9 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,5 +12,6 @@ language_version=1.4
 # Code style
 kotlin.code.style=official
 
-# Memory settings
+# Gradle settings
 org.gradle.jvmargs=-Xmx4g
+org.gradle.parallel=true
-- 
cgit 


From 47e5f565d28f1bf1a5a822e8f30f989abc2ced99 Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Thu, 16 Jul 2020 11:44:25 +0200
Subject: Use kotlin "1.4-M3" artifact

---
 gradle.properties                                                   | 2 +-
 .../org/jetbrains/dokka/it/gradle/Android0GradleIntegrationTest.kt  | 6 +++---
 .../org/jetbrains/dokka/it/gradle/BasicGradleIntegrationTest.kt     | 2 +-
 .../org/jetbrains/dokka/it/gradle/BasicGroovyIntegrationTest.kt     | 2 +-
 .../org/jetbrains/dokka/it/gradle/Multimodule0IntegrationTest.kt    | 2 +-
 .../dokka/it/gradle/Multiplatform0GradleIntegrationTest.kt          | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'gradle.properties')

diff --git a/gradle.properties b/gradle.properties
index 3d00dff9..81b55546 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,7 +2,7 @@ dokka_version_base=1.4-M3
 dokka_publication_channel=dokka
 
 # Kotlin compiler and plugin
-kotlin_version=1.4-M3-eap-197
+kotlin_version=1.4-M3
 kotlin_plugin_version=1.4-M3-release-207
 coroutines_version=1.3.7-1.4-M3
 
diff --git a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Android0GradleIntegrationTest.kt b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Android0GradleIntegrationTest.kt
index 30c3d07f..2a9d7a70 100644
--- a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Android0GradleIntegrationTest.kt
+++ b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Android0GradleIntegrationTest.kt
@@ -15,15 +15,15 @@ class Android0GradleIntegrationTest(override val versions: BuildVersions) : Abst
         @get:Parameters(name = "{0}")
         val versions = BuildVersions.permutations(
             gradleVersions = listOf("6.5.1", "5.6.4"),
-            kotlinVersions = listOf("1.3.72", "1.4-M2-eap-70"),
+            kotlinVersions = listOf("1.3.72", "1.4-M3"),
             androidGradlePluginVersions = listOf("3.5.3", "3.6.3")
         ) + BuildVersions.permutations(
             gradleVersions = listOf("6.5.1", "6.1.1"),
-            kotlinVersions = listOf("1.3.72", "1.4-M2-eap-70"),
+            kotlinVersions = listOf("1.3.72", "1.4-M3"),
             androidGradlePluginVersions = listOf("4.0.0")
         ) + BuildVersions.permutations(
             gradleVersions = listOf("6.5.1"),
-            kotlinVersions = listOf("1.3.72", "1.4-M2-eap-70"),
+            kotlinVersions = listOf("1.3.72", "1.4-M3"),
             androidGradlePluginVersions = listOf("4.1.0-beta02")
         )
     }
diff --git a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/BasicGradleIntegrationTest.kt b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/BasicGradleIntegrationTest.kt
index 929c99aa..30b560e7 100644
--- a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/BasicGradleIntegrationTest.kt
+++ b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/BasicGradleIntegrationTest.kt
@@ -12,7 +12,7 @@ class BasicGradleIntegrationTest(override val versions: BuildVersions) : Abstrac
         @get:Parameters(name = "{0}")
         val versions = BuildVersions.permutations(
             gradleVersions = listOf("6.5.1", "6.4.1", "6.3", "6.2.2", "6.1.1", "6.0", "5.6.4"),
-            kotlinVersions = listOf("1.3.30", "1.3.72", "1.4-M2-eap-70")
+            kotlinVersions = listOf("1.3.30", "1.3.72", "1.4-M3")
         )
     }
 
diff --git a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/BasicGroovyIntegrationTest.kt b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/BasicGroovyIntegrationTest.kt
index 0d812ca9..92b7ec40 100644
--- a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/BasicGroovyIntegrationTest.kt
+++ b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/BasicGroovyIntegrationTest.kt
@@ -16,7 +16,7 @@ class BasicGroovyIntegrationTest(override val versions: BuildVersions) : Abstrac
         @get:Parameterized.Parameters(name = "{0}")
         val versions = BuildVersions.permutations(
             gradleVersions = listOf("6.5.1", "5.6.4"),
-            kotlinVersions = listOf("1.4-M2-eap-70")
+            kotlinVersions = listOf("1.4-M3")
         )
     }
 
diff --git a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Multimodule0IntegrationTest.kt b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Multimodule0IntegrationTest.kt
index 64cf3d75..390db3a0 100644
--- a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Multimodule0IntegrationTest.kt
+++ b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Multimodule0IntegrationTest.kt
@@ -11,7 +11,7 @@ class Multimodule0IntegrationTest(override val versions: BuildVersions) : Abstra
         @get:Parameterized.Parameters(name = "{0}")
         val versions = BuildVersions.permutations(
             gradleVersions = listOf("6.5.1", "6.1.1"),
-            kotlinVersions = listOf("1.4-M2-eap-70")
+            kotlinVersions = listOf("1.4-M3")
         )
     }
 
diff --git a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Multiplatform0GradleIntegrationTest.kt b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Multiplatform0GradleIntegrationTest.kt
index d6d2ff6a..6a3b9c83 100644
--- a/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Multiplatform0GradleIntegrationTest.kt
+++ b/integration-tests/gradle/src/integrationTest/kotlin/org/jetbrains/dokka/it/gradle/Multiplatform0GradleIntegrationTest.kt
@@ -12,7 +12,7 @@ class Multiplatform0GradleIntegrationTest(override val versions: BuildVersions)
         @get:Parameterized.Parameters(name = "{0}")
         val versions = BuildVersions.permutations(
             gradleVersions = listOf("6.5.1", "6.1.1"),
-            kotlinVersions = listOf("1.3.30", "1.3.72", "1.4-M2-eap-70")
+            kotlinVersions = listOf("1.3.30", "1.3.72", "1.4-M3")
         )
     }
 
-- 
cgit