From dac6ba2a589aa1e8a9f4a9c7af32026be77776b3 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Thu, 14 Nov 2019 15:18:56 +0100
Subject: First plugin draft

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 27 ++++++++++++++++++++++++
 core/src/main/kotlin/plugability/DokkaPlugin.kt  |  6 ++++++
 2 files changed, 33 insertions(+)
 create mode 100644 core/src/main/kotlin/plugability/DokkaContext.kt
 create mode 100644 core/src/main/kotlin/plugability/DokkaPlugin.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
new file mode 100644
index 00000000..7da4d9a7
--- /dev/null
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.dokka.plugability
+
+import java.io.File
+import java.net.URLClassLoader
+import java.util.*
+
+
+class DokkaContext private constructor() {
+    private val plugins = mutableListOf<DokkaPlugin>()
+
+    val pluginNames: List<String>
+        get() = plugins.map { it.name }
+
+    private fun install(plugin: DokkaPlugin) {
+        plugins += plugin
+        plugin.install(this)
+    }
+
+    companion object {
+        fun from(pluginsClasspath: Iterable<File>) = DokkaContext().apply {
+            pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
+                .toTypedArray()
+                .let { ServiceLoader.load(DokkaPlugin::class.java, URLClassLoader(it, this.javaClass.classLoader)) }
+                .forEach { install(it) }
+        }
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
new file mode 100644
index 00000000..2654bcee
--- /dev/null
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -0,0 +1,6 @@
+package org.jetbrains.dokka.plugability
+
+interface DokkaPlugin {
+    val name: String
+    fun install(context: DokkaContext)
+}
\ No newline at end of file
-- 
cgit 


From 007aacb9ae3b228d0cef45ff5beb066b1dcd4cdc Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Fri, 15 Nov 2019 10:23:35 +0100
Subject: Adds simplest classpath checking for plugins

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 7da4d9a7..b54d8ed0 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -20,8 +20,17 @@ class DokkaContext private constructor() {
         fun from(pluginsClasspath: Iterable<File>) = DokkaContext().apply {
             pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
                 .toTypedArray()
-                .let { ServiceLoader.load(DokkaPlugin::class.java, URLClassLoader(it, this.javaClass.classLoader)) }
+                .let { URLClassLoader(it, this.javaClass.classLoader) }
+                .also { checkClasspath(it) }
+                .let { ServiceLoader.load(DokkaPlugin::class.java, it) }
                 .forEach { install(it) }
         }
     }
-}
\ No newline at end of file
+
+    private fun checkClasspath(classLoader: URLClassLoader) {
+        classLoader.findResource(javaClass.name.replace('.','/') + ".class")?.also {
+            throw AssertionError("Dokka API found on plugins classpath. This will lead to subtle bugs. " +
+                    "Please fix your plugins dependencies or exclude dokka api artifact from plugin classpath")
+        }
+    }
+}
-- 
cgit 


From 8a057a4611684a6a4616e136d480c005997070cd Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Tue, 19 Nov 2019 16:54:47 +0100
Subject: Working extensions in plugins

---
 .idea/compiler.xml                               |  4 ++
 core/src/main/kotlin/DokkaGenerator.kt           | 36 ++++++---------
 core/src/main/kotlin/plugability/DokkaContext.kt | 30 +++++++++---
 core/src/main/kotlin/plugability/DokkaPlugin.kt  | 58 ++++++++++++++++++++++--
 core/src/main/kotlin/plugability/extensions.kt   | 52 +++++++++++++++++++++
 plugins/mathjax/build.gradle                     |  6 +++
 runners/fatjar/build.gradle                      |  4 +-
 settings.gradle                                  |  3 +-
 8 files changed, 159 insertions(+), 34 deletions(-)
 create mode 100644 core/src/main/kotlin/plugability/extensions.kt
 create mode 100644 plugins/mathjax/build.gradle

(limited to 'core/src/main/kotlin/plugability')

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index e8fe0465..34ea6446 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -44,7 +44,11 @@
       <module name="dokka.integration.test" target="1.8" />
       <module name="dokka.plugins.javadoc8.main" target="1.8" />
       <module name="dokka.plugins.javadoc8.test" target="1.8" />
+      <module name="dokka.plugins.ma.main" target="1.8" />
+      <module name="dokka.plugins.ma.test" target="1.8" />
       <module name="dokka.plugins.main" target="1.8" />
+      <module name="dokka.plugins.mathjax.main" target="1.8" />
+      <module name="dokka.plugins.mathjax.test" target="1.8" />
       <module name="dokka.plugins.test" target="1.8" />
       <module name="dokka.runners.android-gradle-plugin.main" target="1.8" />
       <module name="dokka.runners.android-gradle-plugin.test" target="1.8" />
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index fb4bf98f..f02f1e87 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -26,14 +26,8 @@ class DokkaGenerator(
 
         logger.debug("Initializing plugins")
         val context = DokkaContext.from(configuration.pluginsClasspath)
-        context.pluginNames.also { names ->
-            logger.progress("Loaded plugins: $names")
-            names.groupingBy { it }.eachCount().filter { it.value > 1 }.forEach {
-                logger.warn("Duplicate plugin name: ${it.key}. It will make debugging much harder.")
-            }
-        }
-
-
+        logger.progress("Loaded plugins: ${context.pluginNames}")
+        logger.progress("Loaded: ${context.loadedListForDebug}")
 
         configuration.passesConfigurations.map { pass ->
             AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
@@ -79,23 +73,23 @@ class DokkaGenerator(
                 ).render(it)
             }
     }
-}
 
-private fun nierzigoj(niczym: String) {}
+    private fun nierzigoj(niczym: String) {}
 
-private class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
-    override fun clear() {
-        seenErrors = false
-    }
+    private class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
+        override fun clear() {
+            seenErrors = false
+        }
 
-    private var seenErrors = false
+        private var seenErrors = false
 
-    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
-        if (severity == CompilerMessageSeverity.ERROR) {
-            seenErrors = true
+        override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+            if (severity == CompilerMessageSeverity.ERROR) {
+                seenErrors = true
+            }
+            logger.error(MessageRenderer.PLAIN_FULL_PATHS.render(severity, message, location))
         }
-        logger.error(MessageRenderer.PLAIN_FULL_PATHS.render(severity, message, location))
-    }
 
-    override fun hasErrors() = seenErrors
+        override fun hasErrors() = seenErrors
+    }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index b54d8ed0..d67f34b1 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -3,17 +3,27 @@ package org.jetbrains.dokka.plugability
 import java.io.File
 import java.net.URLClassLoader
 import java.util.*
+import kotlin.reflect.KClass
 
 
 class DokkaContext private constructor() {
-    private val plugins = mutableListOf<DokkaPlugin>()
+    private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
+
+    internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
+
+    @PublishedApi
+    internal fun plugin(kclass: KClass<*>) = plugins[kclass]
 
     val pluginNames: List<String>
-        get() = plugins.map { it.name }
+        get() = plugins.values.map { it::class.qualifiedName.toString() }
+
+    val loadedListForDebug
+        get() = extensions.run { keys + values.flatten() }.toList()
+            .joinToString(prefix = "[\n", separator = ",\n", postfix = "\n]") { "\t$it" }
 
     private fun install(plugin: DokkaPlugin) {
-        plugins += plugin
-        plugin.install(this)
+        plugins[plugin::class] = plugin
+        plugin.internalInstall(this)
     }
 
     companion object {
@@ -28,9 +38,15 @@ class DokkaContext private constructor() {
     }
 
     private fun checkClasspath(classLoader: URLClassLoader) {
-        classLoader.findResource(javaClass.name.replace('.','/') + ".class")?.also {
-            throw AssertionError("Dokka API found on plugins classpath. This will lead to subtle bugs. " +
-                    "Please fix your plugins dependencies or exclude dokka api artifact from plugin classpath")
+        classLoader.findResource(javaClass.name.replace('.', '/') + ".class")?.also {
+            throw AssertionError(
+                "Dokka API found on plugins classpath. This will lead to subtle bugs. " +
+                        "Please fix your plugins dependencies or exclude dokka api artifact from plugin classpath"
+            )
         }
     }
+
+    internal fun addExtension(it: Extension<*>) {
+        extensions.getOrPut(it.extensionPoint, ::mutableListOf) += it
+    }
 }
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 2654bcee..60ca245c 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -1,6 +1,58 @@
 package org.jetbrains.dokka.plugability
 
-interface DokkaPlugin {
-    val name: String
-    fun install(context: DokkaContext)
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KTypeProjection
+import kotlin.reflect.full.createInstance
+import kotlin.reflect.full.createType
+import kotlin.reflect.full.declaredMemberProperties
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.jvmErasure
+
+private typealias ExtensionDelegate<T> = ReadOnlyProperty<DokkaPlugin, Extension<T>>
+
+abstract class DokkaPlugin {
+    private val extensionDelegates = mutableListOf<KProperty<*>>()
+
+    @PublishedApi
+    internal var context: DokkaContext? = null
+
+    protected open fun install(context: DokkaContext) {}
+
+    protected inline fun <reified T : DokkaPlugin> plugin(): T =
+        context?.plugin(T::class) as? T ?: T::class.createInstance().also { it.context = this.context }
+
+    protected fun <T : Any> extensionPoint() =
+        object : ReadOnlyProperty<DokkaPlugin, ExtensionPoint<T>> {
+            override fun getValue(thisRef: DokkaPlugin, property: KProperty<*>) = ExtensionPoint<T>(
+                thisRef::class.qualifiedName ?: throw AssertionError("Plugin must be named class"),
+                property.name
+            )
+        }
+
+    protected fun <T: Any> extending(definition: ExtendingDSL.() -> Extension<T>) = ExtensionProvider(definition)
+
+    protected class ExtensionProvider<T: Any> internal constructor(
+        private val definition: ExtendingDSL.() -> Extension<T>
+    ) {
+        operator fun provideDelegate(thisRef: DokkaPlugin, property: KProperty<*>) = lazy {
+            ExtendingDSL(
+                thisRef::class.qualifiedName ?: throw AssertionError("Plugin must be named class"),
+                property.name
+            ).definition()
+        }.also { thisRef.extensionDelegates += property }
+    }
+
+    internal fun internalInstall(ctx: DokkaContext) {
+        context = ctx
+        install(ctx)
+
+        extensionDelegates.asSequence()
+            .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // always true
+            .map { it.get(this) }
+            .forEach { ctx.addExtension(it) }
+    }
+
+
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
new file mode 100644
index 00000000..c1573e1a
--- /dev/null
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -0,0 +1,52 @@
+package org.jetbrains.dokka.plugability
+
+data class ExtensionPoint<T : Any> internal constructor(
+    internal val pluginClass: String,
+    internal val pointName: String
+) {
+    override fun toString() = "ExtensionPoint: $pluginClass/$pointName"
+}
+
+class Extension<T : Any> internal constructor(
+    internal val extensionPoint: ExtensionPoint<T>,
+    internal val pluginClass: String,
+    internal val extensionName: String,
+    internal val action: T,
+    internal val ordering: (OrderDsl.() -> Unit)? = null
+) {
+    override fun toString() = "Extension: $pluginClass/$extensionName"
+
+    override fun equals(other: Any?) =
+        if (other is Extension<*>) this.pluginClass == other.extensionName && this.extensionName == other.extensionName
+        else false
+
+    override fun hashCode() = listOf(pluginClass, extensionName).hashCode()
+}
+
+internal data class Ordering(val previous: Set<Extension<*>>, val following: Set<Extension<*>>)
+
+@DslMarker
+annotation class ExtensionsDsl
+
+@ExtensionsDsl
+class ExtendingDSL(private val pluginClass: String, private val extensionName: String) {
+    infix fun <T: Any> ExtensionPoint<T>.with(action: T) =
+        Extension(this, this@ExtendingDSL.pluginClass, extensionName, action)
+
+    infix fun <T: Any> Extension<T>.order(block: OrderDsl.() -> Unit) =
+        Extension(extensionPoint, pluginClass, extensionName, action, block)
+}
+
+@ExtensionsDsl
+class OrderDsl {
+    private val previous = mutableSetOf<Extension<*>>()
+    private val following = mutableSetOf<Extension<*>>()
+
+    fun after(vararg extensions: Extension<*>) {
+        previous += extensions
+    }
+
+    fun before(vararg extensions: Extension<*>) {
+        following += extensions
+    }
+}
\ No newline at end of file
diff --git a/plugins/mathjax/build.gradle b/plugins/mathjax/build.gradle
new file mode 100644
index 00000000..a4a59c50
--- /dev/null
+++ b/plugins/mathjax/build.gradle
@@ -0,0 +1,6 @@
+import javax.tools.ToolProvider
+
+
+dependencies {
+    compileOnly project(':core')
+}
\ No newline at end of file
diff --git a/runners/fatjar/build.gradle b/runners/fatjar/build.gradle
index 1da23841..cab64c0f 100644
--- a/runners/fatjar/build.gradle
+++ b/runners/fatjar/build.gradle
@@ -33,7 +33,7 @@ shadowJar {
 
     exclude 'src/**'
 
-    relocate('kotlin.reflect.full', 'kotlin.reflect')
+//    relocate('kotlin.reflect.full', 'kotlin.reflect')
 }
 
 task apiShadow(type: ShadowJar) {
@@ -56,7 +56,7 @@ task apiShadow(type: ShadowJar) {
 
     exclude 'src/**'
 
-    relocate('kotlin.reflect.full', 'kotlin.reflect')
+//    relocate('kotlin.reflect.full', 'kotlin.reflect')
 }
 
 apply plugin: 'maven-publish'
diff --git a/settings.gradle b/settings.gradle
index c793bd79..0447a904 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -9,5 +9,6 @@ include 'core',
         'runners:ant',
         'runners:cli',
 //        'runners:maven-plugin',
-        'runners:gradle-plugin'
+        'runners:gradle-plugin',
 //        'plugins:javadoc8'
+        'plugins:mathjax'
-- 
cgit 


From 87c65d1bf22dc0dbc6da8d007fafc73382432812 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Wed, 20 Nov 2019 08:09:59 +0100
Subject: Mathjax plugin implemented

---
 core/src/main/kotlin/CoreExtensions.kt             |  8 +++
 core/src/main/kotlin/DokkaGenerator.kt             |  7 +-
 core/src/main/kotlin/pages/PageNodes.kt            | 82 ++++++++++++++++++----
 core/src/main/kotlin/plugability/DokkaContext.kt   |  3 +
 core/src/main/kotlin/renderers/HtmlRenderer.kt     |  8 +++
 .../kotlin/transformers/PageNodeTransformer.kt     |  8 +++
 plugins/mathjax/build.gradle                       | 11 +++
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt   | 35 +++++++++
 .../org.jetbrains.dokka.plugability.DokkaPlugin    |  1 +
 9 files changed, 146 insertions(+), 17 deletions(-)
 create mode 100644 core/src/main/kotlin/CoreExtensions.kt
 create mode 100644 core/src/main/kotlin/transformers/PageNodeTransformer.kt
 create mode 100644 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
 create mode 100644 plugins/mathjax/src/main/resources/META-INF/services/org.jetbrains.dokka.plugability.DokkaPlugin

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
new file mode 100644
index 00000000..32559d52
--- /dev/null
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.dokka
+
+import org.jetbrains.dokka.plugability.ExtensionPoint
+import org.jetbrains.dokka.transformers.PageNodeTransformer
+
+object CoreExtensions {
+    val pageTransformer = ExtensionPoint<PageNodeTransformer>(this::class.qualifiedName!!, "pageTransformer")
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index f02f1e87..129549b9 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -62,11 +62,10 @@ class DokkaGenerator(
             }
         }.let {
             val markdownConverter = MarkdownToContentConverter(logger)
-//            it.forEach { it.genericPretty().also(::nierzigoj) }
             DefaultDocumentationToPageTransformer(markdownConverter, logger).transform(DocumentationNodesMerger(it))
-        }
-            .also {
-//                it.genericPretty().also(::nierzigoj)
+        }.let {
+            context[CoreExtensions.pageTransformer].fold(it) { pn, t -> t.action.invoke(pn, context) }
+        }.also {
                 HtmlRenderer(
                     FileWriter(configuration.outputDir, ""),
                     DefaultLocationProvider(it, configuration, ".${configuration.format}")
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index 0d6072f7..810cd776 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -10,10 +10,18 @@ interface PageNode {
     val parent: PageNode?
     val dri: DRI
     val documentationNode: DocumentationNode<*>?
+    val embeddedResources: List<String>
     val children: List<PageNode>
+
+    fun modified(
+        name: String = this.name,
+        content: ContentNode = this.content,
+        embeddedResources: List<String> = this.embeddedResources,
+        children: List<PageNode> = this.children
+    ): PageNode
 }
 
-abstract class BasicPageNode(children: List<PageNode>): PageNode {
+abstract class BasicPageNode(children: List<PageNode>) : PageNode {
 
     private lateinit var _parent: PageNode
     override val parent: PageNode? by lazy { _parent }
@@ -22,8 +30,7 @@ abstract class BasicPageNode(children: List<PageNode>): PageNode {
     override fun equals(other: Any?): Boolean =
         if (other is PageNode) {
             dri == other.dri && name == other.name
-        }
-        else false
+        } else false
 
     override fun hashCode(): Int =
         (name + dri).hashCode()
@@ -31,17 +38,26 @@ abstract class BasicPageNode(children: List<PageNode>): PageNode {
     init {
         children.forEach { if (it is BasicPageNode) it._parent = this }
     }
-
 }
 
 class ModulePageNode(
     override val name: String,
     override val content: ContentNode,
     override val documentationNode: DocumentationNode<*>?,
-    children: List<PageNode>
-): BasicPageNode(children) {
+    children: List<PageNode>,
+    override val embeddedResources: List<String> = listOf()
+) : BasicPageNode(children) {
     override val parent: Nothing? = null
     override val dri: DRI = DRI.topLevel
+
+    override fun modified(
+        name: String,
+        content: ContentNode,
+        embeddedResources: List<String>,
+        children: List<PageNode>
+    ): ModulePageNode =
+        if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
+        else ModulePageNode(name, content, documentationNode, children, embeddedResources)
 }
 
 class PackagePageNode(
@@ -49,30 +65,70 @@ class PackagePageNode(
     override val content: ContentNode,
     override val dri: DRI,
     override val documentationNode: DocumentationNode<*>?,
-    children: List<PageNode>
-): BasicPageNode(children)
+    children: List<PageNode>,
+    override val embeddedResources: List<String> = listOf()
+) : BasicPageNode(children) {
+
+    override fun modified(
+        name: String,
+        content: ContentNode,
+        embeddedResources: List<String>,
+        children: List<PageNode>
+    ): PackagePageNode =
+        if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
+        else PackagePageNode(name, content, dri, documentationNode, children, embeddedResources)
+}
 
 class ClassPageNode(
     override val name: String,
     override val content: ContentNode,
     override val dri: DRI,
     override val documentationNode: DocumentationNode<*>?,
-    children: List<PageNode>
-): BasicPageNode(children)
+    children: List<PageNode>,
+    override val embeddedResources: List<String> = listOf()
+) : BasicPageNode(children) {
+
+    override fun modified(
+        name: String,
+        content: ContentNode,
+        embeddedResources: List<String>,
+        children: List<PageNode>
+    ): ClassPageNode =
+        if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
+        else ClassPageNode(name, content, dri, documentationNode, children, embeddedResources)
+}
 
 class MemberPageNode(
     override val name: String,
     override val content: ContentNode,
     override val dri: DRI,
     override val documentationNode: DocumentationNode<*>?,
-    children: List<PageNode> = emptyList()
-): BasicPageNode(children)
+    children: List<PageNode> = emptyList(),
+    override val embeddedResources: List<String> = listOf()
+) : BasicPageNode(children) {
+
+    override fun modified(
+        name: String,
+        content: ContentNode,
+        embeddedResources: List<String>,
+        children: List<PageNode>
+    ): MemberPageNode =
+        if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
+        else MemberPageNode(name, content, dri, documentationNode, children, embeddedResources)
+}
 
 data class PlatformData(val platformType: Platform, val targets: List<String>) {
     override fun toString() = targets.toString()
 }
 
-fun PageNode.dfs(predicate: (PageNode) -> Boolean): PageNode? = if (predicate(this)) { this } else { this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull() }
+fun PageNode.dfs(predicate: (PageNode) -> Boolean): PageNode? = if (predicate(this)) {
+    this
+} else {
+    this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull()
+}
+
+private infix fun <T> List<T>.shallowEq(other: List<T>) =
+    this === other || (this.size == other.size && (this zip other).all { (a, b) -> a === b })
 
 // Navigation??
 
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index d67f34b1..dcd3398e 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -11,6 +11,9 @@ class DokkaContext private constructor() {
 
     internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
 
+    @Suppress("UNCHECKED_CAST")
+    operator fun <T: Any, E: ExtensionPoint<T>> get(point: E) = extensions[point] as List<Extension<T>>
+
     @PublishedApi
     internal fun plugin(kclass: KClass<*>) = plugins[kclass]
 
diff --git a/core/src/main/kotlin/renderers/HtmlRenderer.kt b/core/src/main/kotlin/renderers/HtmlRenderer.kt
index f750140a..3b778671 100644
--- a/core/src/main/kotlin/renderers/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/HtmlRenderer.kt
@@ -4,6 +4,9 @@ import org.jetbrains.dokka.htmlEscape
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.resolvers.LocationProvider
 import java.io.File
+import java.net.URL
+import java.nio.file.Path
+import java.nio.file.Paths
 
 open class HtmlRenderer(fileWriter: FileWriter, locationProvider: LocationProvider) : DefaultRenderer(fileWriter, locationProvider) {
 
@@ -69,11 +72,16 @@ open class HtmlRenderer(fileWriter: FileWriter, locationProvider: LocationProvid
         )
     }
 
+    protected open fun buildScripts(page: PageNode) =
+        page.embeddedResources.filter { URL(it).path.substringAfterLast('.') == "js" }
+            .joinToString(separator = "") { """<script type = "text/javascript" async src = "$it"></script>""" + "\n" }
+
     protected open fun buildStartHtml(page: PageNode) = """<!DOCTYPE html>
         |<html>
         |<head>
         |<title>${page.name}</title>
         |<link rel="stylesheet" href="${locationProvider.resolveRoot(page)}style.css" />
+        |${buildScripts(page)}
         |</head>
         |<body>
         |""".trimMargin()
diff --git a/core/src/main/kotlin/transformers/PageNodeTransformer.kt b/core/src/main/kotlin/transformers/PageNodeTransformer.kt
new file mode 100644
index 00000000..b86e0b34
--- /dev/null
+++ b/core/src/main/kotlin/transformers/PageNodeTransformer.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.dokka.transformers
+
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface PageNodeTransformer {
+    fun invoke(input: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode
+}
\ No newline at end of file
diff --git a/plugins/mathjax/build.gradle b/plugins/mathjax/build.gradle
index a4a59c50..6578ff45 100644
--- a/plugins/mathjax/build.gradle
+++ b/plugins/mathjax/build.gradle
@@ -1,6 +1,17 @@
 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/src/main/kotlin/MathjaxPlugin.kt b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
new file mode 100644
index 00000000..63512966
--- /dev/null
+++ b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
@@ -0,0 +1,35 @@
+package  org.jetbrains.dokka.mathjax
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.transformers.PageNodeTransformer
+
+class MathjaxPlugin : DokkaPlugin() {
+    val transformer by extending {
+        CoreExtensions.pageTransformer with MathjaxTransformer
+    }
+}
+
+private const val ANNOTATION = "@usesMathJax"
+private const val LIB_PATH = "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.6/MathJax.js?config=TeX-AMS_SVG&latest"
+
+object MathjaxTransformer : PageNodeTransformer {
+    override fun invoke(input: ModulePageNode, dokkaContext: DokkaContext) = input.modified(
+        children = input.children.map { transform(it) }
+    )
+
+    private fun transform(input: PageNode): PageNode = input.modified(
+        embeddedResources = input.embeddedResources + if (input.isNeedingMathjax) listOf(LIB_PATH) else emptyList(),
+        children = input.children.map { transform(it) }
+    )
+
+
+    private val PageNode.isNeedingMathjax
+        get() = documentationNode?.descriptors
+            ?.flatMap { it.docTag?.children?.toList().orEmpty() }
+            .orEmpty()
+            .any { it.text == ANNOTATION }
+}
\ No newline at end of file
diff --git a/plugins/mathjax/src/main/resources/META-INF/services/org.jetbrains.dokka.plugability.DokkaPlugin b/plugins/mathjax/src/main/resources/META-INF/services/org.jetbrains.dokka.plugability.DokkaPlugin
new file mode 100644
index 00000000..9f9736f3
--- /dev/null
+++ b/plugins/mathjax/src/main/resources/META-INF/services/org.jetbrains.dokka.plugability.DokkaPlugin
@@ -0,0 +1 @@
+org.jetbrains.dokka.mathjax.MathjaxPlugin
-- 
cgit 


From a945617725e8df084270aacd5af76da2b911111e Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 25 Nov 2019 15:34:47 +0100
Subject: Interface segregation in plugins api

---
 core/src/main/kotlin/DokkaGenerator.kt           |  4 +-
 core/src/main/kotlin/plugability/DokkaContext.kt | 82 +++++++++++++++---------
 core/src/main/kotlin/plugability/DokkaPlugin.kt  | 14 +---
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt |  1 +
 4 files changed, 55 insertions(+), 46 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index b29a0da2..05eb3054 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -25,9 +25,7 @@ class DokkaGenerator(
     fun generate(): Unit {
 
         logger.debug("Initializing plugins")
-        val context = DokkaContext.from(configuration.pluginsClasspath)
-        logger.progress("Loaded plugins: ${context.pluginNames}")
-        logger.progress("Loaded: ${context.loadedListForDebug}")
+        val context = DokkaContext.create(configuration.pluginsClasspath, logger)
 
         configuration.passesConfigurations.map { pass ->
             AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index dcd3398e..7727329c 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,55 +1,75 @@
 package org.jetbrains.dokka.plugability
 
+import org.jetbrains.dokka.DokkaLogger
 import java.io.File
 import java.net.URLClassLoader
 import java.util.*
 import kotlin.reflect.KClass
 
+interface DokkaContext {
+    operator fun <T : Any, E : ExtensionPoint<T>> get(point: E): List<Extension<T>>
 
-class DokkaContext private constructor() {
+    fun <T : DokkaPlugin> plugin(kclass: KClass<T>): T?
+
+    val logger: DokkaLogger
+
+    companion object {
+        fun create(pluginsClasspath: Iterable<File>, logger: DokkaLogger): DokkaContext =
+            DokkaContextConfigurationImpl(logger).apply {
+                pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
+                    .toTypedArray()
+                    .let { URLClassLoader(it, this.javaClass.classLoader) }
+                    .also { checkClasspath(it) }
+                    .let { ServiceLoader.load(DokkaPlugin::class.java, it) }
+                    .forEach { install(it) }
+            }.also { it.logInitialisationInfo() }
+    }
+}
+
+interface DokkaContextConfiguration {
+    fun addExtension(extension: Extension<*>)
+}
+
+private class DokkaContextConfigurationImpl(
+    override val logger: DokkaLogger
+) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
 
     internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
 
     @Suppress("UNCHECKED_CAST")
-    operator fun <T: Any, E: ExtensionPoint<T>> get(point: E) = extensions[point] as List<Extension<T>>
-
-    @PublishedApi
-    internal fun plugin(kclass: KClass<*>) = plugins[kclass]
-
-    val pluginNames: List<String>
-        get() = plugins.values.map { it::class.qualifiedName.toString() }
+    override operator fun <T : Any, E : ExtensionPoint<T>> get(point: E) = extensions[point] as List<Extension<T>>
 
-    val loadedListForDebug
-        get() = extensions.run { keys + values.flatten() }.toList()
-            .joinToString(prefix = "[\n", separator = ",\n", postfix = "\n]") { "\t$it" }
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>) = plugins[kclass] as T
 
-    private fun install(plugin: DokkaPlugin) {
+    fun install(plugin: DokkaPlugin) {
         plugins[plugin::class] = plugin
+        plugin.context = this
         plugin.internalInstall(this)
     }
 
-    companion object {
-        fun from(pluginsClasspath: Iterable<File>) = DokkaContext().apply {
-            pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
-                .toTypedArray()
-                .let { URLClassLoader(it, this.javaClass.classLoader) }
-                .also { checkClasspath(it) }
-                .let { ServiceLoader.load(DokkaPlugin::class.java, it) }
-                .forEach { install(it) }
-        }
+    override fun addExtension(extension: Extension<*>) {
+        extensions.getOrPut(extension.extensionPoint, ::mutableListOf) += extension
     }
 
-    private fun checkClasspath(classLoader: URLClassLoader) {
-        classLoader.findResource(javaClass.name.replace('.', '/') + ".class")?.also {
-            throw AssertionError(
-                "Dokka API found on plugins classpath. This will lead to subtle bugs. " +
-                        "Please fix your plugins dependencies or exclude dokka api artifact from plugin classpath"
-            )
-        }
-    }
+    fun logInitialisationInfo() {
+        val pluginNames: List<String> = plugins.values.map { it::class.qualifiedName.toString() }
+
+        val loadedListForDebug = extensions.run { keys + values.flatten() }.toList()
+            .joinToString(prefix = "[\n", separator = ",\n", postfix = "\n]") { "\t$it" }
+
+        logger.progress("Loaded plugins: ${pluginNames}")
+        logger.progress("Loaded: ${loadedListForDebug}")
 
-    internal fun addExtension(it: Extension<*>) {
-        extensions.getOrPut(it.extensionPoint, ::mutableListOf) += it
     }
 }
+
+private fun checkClasspath(classLoader: URLClassLoader) {
+    classLoader.findResource(DokkaContext::class.java.name.replace('.', '/') + ".class")?.also {
+        throw AssertionError(
+            "Dokka API found on plugins classpath. This will lead to subtle bugs. " +
+                    "Please fix your plugins dependencies or exclude dokka api artifact from plugin classpath"
+        )
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 60ca245c..663cf88e 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -3,12 +3,7 @@ package org.jetbrains.dokka.plugability
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
-import kotlin.reflect.KTypeProjection
 import kotlin.reflect.full.createInstance
-import kotlin.reflect.full.createType
-import kotlin.reflect.full.declaredMemberProperties
-import kotlin.reflect.jvm.isAccessible
-import kotlin.reflect.jvm.jvmErasure
 
 private typealias ExtensionDelegate<T> = ReadOnlyProperty<DokkaPlugin, Extension<T>>
 
@@ -18,10 +13,8 @@ abstract class DokkaPlugin {
     @PublishedApi
     internal var context: DokkaContext? = null
 
-    protected open fun install(context: DokkaContext) {}
-
     protected inline fun <reified T : DokkaPlugin> plugin(): T =
-        context?.plugin(T::class) as? T ?: T::class.createInstance().also { it.context = this.context }
+        context?.plugin(T::class) ?: T::class.createInstance().also { it.context = this.context }
 
     protected fun <T : Any> extensionPoint() =
         object : ReadOnlyProperty<DokkaPlugin, ExtensionPoint<T>> {
@@ -44,10 +37,7 @@ abstract class DokkaPlugin {
         }.also { thisRef.extensionDelegates += property }
     }
 
-    internal fun internalInstall(ctx: DokkaContext) {
-        context = ctx
-        install(ctx)
-
+    internal fun internalInstall(ctx: DokkaContextConfiguration) {
         extensionDelegates.asSequence()
             .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // always true
             .map { it.get(this) }
diff --git a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
index 0decfb1c..b7b2d505 100644
--- a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
+++ b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
@@ -4,6 +4,7 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.DokkaContextConfiguration
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.transformers.PageNodeTransformer
 
-- 
cgit 


From 893dd637e3727d455e82f72ff90e823c6e017f7a Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 25 Nov 2019 15:48:08 +0100
Subject: Cache for plugin stubs

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 12 +++++++++---
 core/src/main/kotlin/plugability/DokkaPlugin.kt  | 11 +++++------
 2 files changed, 14 insertions(+), 9 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 7727329c..a5bcd695 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -5,6 +5,7 @@ import java.io.File
 import java.net.URLClassLoader
 import java.util.*
 import kotlin.reflect.KClass
+import kotlin.reflect.full.createInstance
 
 interface DokkaContext {
     operator fun <T : Any, E : ExtensionPoint<T>> get(point: E): List<Extension<T>>
@@ -35,13 +36,18 @@ private class DokkaContextConfigurationImpl(
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
 
+    private val pluginStubs = mutableMapOf<KClass<*>, DokkaPlugin>()
+
     internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
 
     @Suppress("UNCHECKED_CAST")
     override operator fun <T : Any, E : ExtensionPoint<T>> get(point: E) = extensions[point] as List<Extension<T>>
 
     @Suppress("UNCHECKED_CAST")
-    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>) = plugins[kclass] as T
+    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>) = (plugins[kclass] ?: pluginStubFor(kclass)) as T
+
+    private fun <T : DokkaPlugin> pluginStubFor(kclass: KClass<T>): DokkaPlugin =
+        pluginStubs.getOrPut(kclass) { kclass.createInstance().also { it.context = this } }
 
     fun install(plugin: DokkaPlugin) {
         plugins[plugin::class] = plugin
@@ -59,8 +65,8 @@ private class DokkaContextConfigurationImpl(
         val loadedListForDebug = extensions.run { keys + values.flatten() }.toList()
             .joinToString(prefix = "[\n", separator = ",\n", postfix = "\n]") { "\t$it" }
 
-        logger.progress("Loaded plugins: ${pluginNames}")
-        logger.progress("Loaded: ${loadedListForDebug}")
+        logger.progress("Loaded plugins: $pluginNames")
+        logger.progress("Loaded: $loadedListForDebug")
 
     }
 }
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 663cf88e..7a968b8b 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -3,7 +3,6 @@ package org.jetbrains.dokka.plugability
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
-import kotlin.reflect.full.createInstance
 
 private typealias ExtensionDelegate<T> = ReadOnlyProperty<DokkaPlugin, Extension<T>>
 
@@ -13,8 +12,8 @@ abstract class DokkaPlugin {
     @PublishedApi
     internal var context: DokkaContext? = null
 
-    protected inline fun <reified T : DokkaPlugin> plugin(): T =
-        context?.plugin(T::class) ?: T::class.createInstance().also { it.context = this.context }
+    protected inline fun <reified T : DokkaPlugin> plugin(): T = context?.plugin(T::class)
+            ?: throw IllegalStateException("Querying about plugins is only possible with dokka context initialised")
 
     protected fun <T : Any> extensionPoint() =
         object : ReadOnlyProperty<DokkaPlugin, ExtensionPoint<T>> {
@@ -24,9 +23,9 @@ abstract class DokkaPlugin {
             )
         }
 
-    protected fun <T: Any> extending(definition: ExtendingDSL.() -> Extension<T>) = ExtensionProvider(definition)
+    protected fun <T : Any> extending(definition: ExtendingDSL.() -> Extension<T>) = ExtensionProvider(definition)
 
-    protected class ExtensionProvider<T: Any> internal constructor(
+    protected class ExtensionProvider<T : Any> internal constructor(
         private val definition: ExtendingDSL.() -> Extension<T>
     ) {
         operator fun provideDelegate(thisRef: DokkaPlugin, property: KProperty<*>) = lazy {
@@ -39,7 +38,7 @@ abstract class DokkaPlugin {
 
     internal fun internalInstall(ctx: DokkaContextConfiguration) {
         extensionDelegates.asSequence()
-            .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // always true
+            .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // should be always true
             .map { it.get(this) }
             .forEach { ctx.addExtension(it) }
     }
-- 
cgit 


From 202845bf4c9e72cfcda578a548f32bc7cc04f64d Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 25 Nov 2019 17:45:23 +0100
Subject: Default context for dokka

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 33 ++++++++++++++++++++----
 1 file changed, 28 insertions(+), 5 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index a5bcd695..b917ff99 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -8,7 +8,8 @@ import kotlin.reflect.KClass
 import kotlin.reflect.full.createInstance
 
 interface DokkaContext {
-    operator fun <T : Any, E : ExtensionPoint<T>> get(point: E): List<Extension<T>>
+    operator fun <T, E> get(point: E, askDefault: AskDefault = AskDefault.WhenEmpty): List<Extension<T>>
+            where T : Any, E : ExtensionPoint<T>
 
     fun <T : DokkaPlugin> plugin(kclass: KClass<T>): T?
 
@@ -16,7 +17,7 @@ interface DokkaContext {
 
     companion object {
         fun create(pluginsClasspath: Iterable<File>, logger: DokkaLogger): DokkaContext =
-            DokkaContextConfigurationImpl(logger).apply {
+            DokkaContextConfigurationImpl(logger, DefaultContext(logger)).apply {
                 pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
                     .toTypedArray()
                     .let { URLClassLoader(it, this.javaClass.classLoader) }
@@ -32,7 +33,8 @@ interface DokkaContextConfiguration {
 }
 
 private class DokkaContextConfigurationImpl(
-    override val logger: DokkaLogger
+    override val logger: DokkaLogger,
+    private val defaultContext: DokkaContext?
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
 
@@ -41,10 +43,17 @@ private class DokkaContextConfigurationImpl(
     internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
 
     @Suppress("UNCHECKED_CAST")
-    override operator fun <T : Any, E : ExtensionPoint<T>> get(point: E) = extensions[point] as List<Extension<T>>
+    override operator fun <T, E> get(point: E, askDefault: AskDefault) where T : Any, E : ExtensionPoint<T> =
+        when (askDefault) {
+            AskDefault.Never -> extensions[point].orEmpty()
+            AskDefault.Always -> extensions[point].orEmpty() + defaultContext?.get(point, askDefault).orEmpty()
+            AskDefault.WhenEmpty ->
+                extensions[point]?.takeIf { it.isNotEmpty() } ?: defaultContext?.get(point, askDefault).orEmpty()
+        } as List<Extension<T>>
 
     @Suppress("UNCHECKED_CAST")
-    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>) = (plugins[kclass] ?: pluginStubFor(kclass)) as T
+    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>) =
+        (plugins[kclass] ?: defaultContext?.plugin(kclass) ?: pluginStubFor(kclass)) as T
 
     private fun <T : DokkaPlugin> pluginStubFor(kclass: KClass<T>): DokkaPlugin =
         pluginStubs.getOrPut(kclass) { kclass.createInstance().also { it.context = this } }
@@ -78,4 +87,18 @@ private fun checkClasspath(classLoader: URLClassLoader) {
                     "Please fix your plugins dependencies or exclude dokka api artifact from plugin classpath"
         )
     }
+}
+
+class DefaultContext(override val logger: DokkaLogger) : DokkaContext {
+    override fun <T : Any, E : ExtensionPoint<T>> get(point: E, askDefault: AskDefault): List<Extension<T>> =
+        when (point) {
+
+            else -> emptyList()
+        }
+
+    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>): Nothing? = null
+}
+
+enum class AskDefault {
+    Always, Never, WhenEmpty
 }
\ No newline at end of file
-- 
cgit 


From 49439594f86217d8a25e8df2580b8ef29d836230 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Tue, 26 Nov 2019 13:44:27 +0100
Subject: Introduction of all important extension points and restructuring of
 DokkaGenerator

---
 .idea/compiler.xml                                 |   2 +
 core/src/main/kotlin/CoreExtensions.kt             |  35 +++-
 core/src/main/kotlin/DokkaDescriptorVisitor.kt     | 191 -----------------
 core/src/main/kotlin/DokkaGenerator.kt             | 183 +++++++++++-----
 core/src/main/kotlin/Model/DocumentationNode.kt    |   2 +-
 .../transformers/DocumentationNodeTransformer.kt   |   8 -
 .../Model/transformers/DocumentationNodesMerger.kt |  90 --------
 .../pages/DefaultMarkdownToContentConverter.kt     | 229 +++++++++++++++++++++
 .../kotlin/pages/MarkdownToContentConverter.kt     | 219 +-------------------
 .../pages/transformers/PageNodeTransformer.kt      |   7 -
 .../main/kotlin/plugability/DefaultExtensions.kt   |  25 +++
 core/src/main/kotlin/plugability/DokkaContext.kt   |  61 ++++--
 core/src/main/kotlin/plugability/extensions.kt     |   2 +-
 core/src/main/kotlin/renderers/DefaultRenderer.kt  |   7 +-
 core/src/main/kotlin/renderers/HtmlRenderer.kt     |   7 +-
 core/src/main/kotlin/renderers/Renderer.kt         |   1 +
 .../kotlin/resolvers/DefaultLocationProvider.kt    |  11 +-
 .../DefaultDocumentationToPageTransformer.kt       |  20 --
 .../transformers/DocumentationToPageTransformer.kt |  11 -
 .../kotlin/transformers/PageNodeTransformer.kt     |   8 -
 .../DefaultDescriptorToDocumentationTranslator.kt  | 208 +++++++++++++++++++
 .../DescriptorToDocumentationTranslator.kt         |  15 ++
 .../DefaultDocumentationNodeMerger.kt              |  86 ++++++++
 .../DefaultDocumentationToPageTranslator.kt        |  24 +++
 .../documentation/DocumentationNodeMerger.kt       |   8 +
 .../documentation/DocumentationNodeTransformer.kt  |   8 +
 .../documentation/DocumentationToPageTranslator.kt |  12 ++
 .../transformers/pages/PageNodeTransformer.kt      |   8 +
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt   |   3 +-
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |  10 +-
 30 files changed, 861 insertions(+), 640 deletions(-)
 delete mode 100644 core/src/main/kotlin/DokkaDescriptorVisitor.kt
 delete mode 100644 core/src/main/kotlin/Model/transformers/DocumentationNodeTransformer.kt
 delete mode 100644 core/src/main/kotlin/Model/transformers/DocumentationNodesMerger.kt
 create mode 100644 core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
 delete mode 100644 core/src/main/kotlin/pages/transformers/PageNodeTransformer.kt
 create mode 100644 core/src/main/kotlin/plugability/DefaultExtensions.kt
 delete mode 100644 core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
 delete mode 100644 core/src/main/kotlin/transformers/DocumentationToPageTransformer.kt
 delete mode 100644 core/src/main/kotlin/transformers/PageNodeTransformer.kt
 create mode 100644 core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
 create mode 100644 core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
 create mode 100644 core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
 create mode 100644 core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
 create mode 100644 core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
 create mode 100644 core/src/main/kotlin/transformers/documentation/DocumentationNodeTransformer.kt
 create mode 100644 core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
 create mode 100644 core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 34ea6446..e78fe4d3 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -50,6 +50,8 @@
       <module name="dokka.plugins.mathjax.main" target="1.8" />
       <module name="dokka.plugins.mathjax.test" target="1.8" />
       <module name="dokka.plugins.test" target="1.8" />
+      <module name="dokka.plugins.xml.main" target="1.8" />
+      <module name="dokka.plugins.xml.test" target="1.8" />
       <module name="dokka.runners.android-gradle-plugin.main" target="1.8" />
       <module name="dokka.runners.android-gradle-plugin.test" target="1.8" />
       <module name="dokka.runners.ant.main" target="1.8" />
diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 6579cab2..f56cd854 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -1,14 +1,37 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.Model.transformers.DocumentationNodeTransformer
+import org.jetbrains.dokka.pages.MarkdownToContentConverter
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.ExtensionPoint
+import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.Renderer
 import org.jetbrains.dokka.resolvers.LocationProvider
-import org.jetbrains.dokka.transformers.PageNodeTransformer
+import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTranslator
+import org.jetbrains.dokka.transformers.documentation.DocumentationNodeMerger
+import org.jetbrains.dokka.transformers.documentation.DocumentationNodeTransformer
+import org.jetbrains.dokka.transformers.documentation.DocumentationToPageTranslator
+import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
+import kotlin.reflect.KProperty
 
+
+/**
+ * Extension points declared by dokka core.
+ * Default values are stored in [org.jetbrains.dokka.plugability.DefaultExtensions]
+ */
 object CoreExtensions {
-    val nodeTransformer = ExtensionPoint<DocumentationNodeTransformer>(this::class.qualifiedName!!, "nodeTransformer")
-    val pageTransformer = ExtensionPoint<PageNodeTransformer>(this::class.qualifiedName!!, "pageTransformer")
-    val renderer = ExtensionPoint<Renderer>(this::class.qualifiedName!!, "renderer")
-    val locationProvider = ExtensionPoint<LocationProvider>(this::class.qualifiedName!!, "locationProvider")
+    val descriptorToDocumentationTranslator by coreExtension<DescriptorToDocumentationTranslator>()
+    val documentationMerger by coreExtension<DocumentationNodeMerger>()
+    val documentationTransformer by coreExtension<DocumentationNodeTransformer>()
+    val markdownToContentConverterFactory by coreExtension<(DokkaContext) -> MarkdownToContentConverter>()
+    val documentationToPageTranslator by coreExtension<DocumentationToPageTranslator>()
+    val pageTransformer by coreExtension<PageNodeTransformer>()
+    val renderer by coreExtension<(FileWriter, LocationProvider, DokkaContext) -> Renderer>()
+    val locationProvider by coreExtension<(root: PageNode, DokkaConfiguration, DokkaContext) -> LocationProvider>()
+    val fileExtension by coreExtension<String>()
+
+    private fun <T: Any> coreExtension() = object {
+        operator fun provideDelegate(thisRef: CoreExtensions, property: KProperty<*>): Lazy<ExtensionPoint<T>> =
+            lazy { ExtensionPoint<T>(thisRef::class.qualifiedName!!, property.name) }
+    }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/DokkaDescriptorVisitor.kt b/core/src/main/kotlin/DokkaDescriptorVisitor.kt
deleted file mode 100644
index 6c82f2c3..00000000
--- a/core/src/main/kotlin/DokkaDescriptorVisitor.kt
+++ /dev/null
@@ -1,191 +0,0 @@
-package org.jetbrains.dokka
-
-import org.jetbrains.dokka.Model.*
-import org.jetbrains.dokka.Model.ClassKind
-import org.jetbrains.dokka.Model.Function
-import org.jetbrains.dokka.links.Callable
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.links.withClass
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
-import org.jetbrains.kotlin.idea.kdoc.findKDoc
-import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocLink
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
-import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.types.KotlinType
-
-class DokkaDescriptorVisitor(
-    private val platformData: PlatformData,
-    private val resolutionFacade: DokkaResolutionFacade
-) : DeclarationDescriptorVisitorEmptyBodies<DocumentationNode, DRI>() {
-    override fun visitDeclarationDescriptor(descriptor: DeclarationDescriptor, parent: DRI): Nothing {
-        throw IllegalStateException("${javaClass.simpleName} should never enter ${descriptor.javaClass.simpleName}")
-    }
-
-    override fun visitPackageFragmentDescriptor(
-        descriptor: PackageFragmentDescriptor,
-        parent: DRI
-    ): Package {
-        val dri = DRI(packageName = descriptor.fqName.asString())
-        val scope = descriptor.getMemberScope()
-        return Package(
-            dri,
-            scope.functions(dri),
-            scope.properties(dri),
-            scope.classes(dri)
-        )
-    }
-
-    override fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRI): Class {
-        val dri = parent.withClass(descriptor.name.asString())
-        val scope = descriptor.getMemberScope(emptyList())
-        val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
-        return Class(
-            dri,
-            descriptor.name.asString(),
-            KotlinClassKindTypes.valueOf(descriptor.kind.toString()),
-            descriptor.constructors.map { visitConstructorDescriptor(it, dri) },
-            scope.functions(dri),
-            scope.properties(dri),
-            scope.classes(dri),
-            descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData(),
-            listOfNotNull(descriptorData),
-            getXMLDRIs(descriptor, descriptorData).toMutableSet()
-        )
-    }
-
-    override fun visitPropertyDescriptor(descriptor: PropertyDescriptor, parent: DRI): Property {
-        val dri = parent.copy(callable = Callable.from(descriptor))
-        return Property(
-            dri,
-            descriptor.name.asString(),
-            descriptor.extensionReceiverParameter?.let { visitReceiverParameterDescriptor(it, dri) },
-            descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
-            listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
-        )
-    }
-
-    override fun visitFunctionDescriptor(descriptor: FunctionDescriptor, parent: DRI): Function {
-        val dri = parent.copy(callable = Callable.from(descriptor))
-        return Function(
-            dri,
-            descriptor.name.asString(),
-            descriptor.returnType?.let { KotlinTypeWrapper(it) },
-            false,
-            descriptor.extensionReceiverParameter?.let { visitReceiverParameterDescriptor(it, dri) },
-            descriptor.valueParameters.mapIndexed { index, desc -> parameter(index, desc, dri) },
-            descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
-            listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
-        )
-    }
-
-    override fun visitConstructorDescriptor(descriptor: ConstructorDescriptor, parent: DRI): Function {
-        val dri = parent.copy(callable = Callable.from(descriptor))
-        return Function(
-            dri,
-            "<init>",
-            KotlinTypeWrapper(descriptor.returnType),
-            true,
-            null,
-            descriptor.valueParameters.mapIndexed { index, desc -> parameter(index, desc, dri) },
-            descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
-            listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
-        )
-    }
-
-    override fun visitReceiverParameterDescriptor(
-        descriptor: ReceiverParameterDescriptor,
-        parent: DRI
-    ) = Parameter(
-        parent.copy(target = 0),
-        null,
-        KotlinTypeWrapper(descriptor.type),
-        listOf(descriptor.resolveDescriptorData())
-    )
-
-    private fun parameter(index: Int, descriptor: ValueParameterDescriptor, parent: DRI) =
-        Parameter(
-            parent.copy(target = index + 1),
-            descriptor.name.asString(),
-            KotlinTypeWrapper(descriptor.type),
-            listOf(descriptor.resolveDescriptorData())
-        )
-
-    private fun MemberScope.functions(parent: DRI): List<Function> =
-        getContributedDescriptors(DescriptorKindFilter.FUNCTIONS) { true }
-            .filterIsInstance<FunctionDescriptor>()
-            .map { visitFunctionDescriptor(it, parent) }
-
-    private fun MemberScope.properties(parent: DRI): List<Property> =
-        getContributedDescriptors(DescriptorKindFilter.VALUES) { true }
-            .filterIsInstance<PropertyDescriptor>()
-            .map { visitPropertyDescriptor(it, parent) }
-
-    private fun MemberScope.classes(parent: DRI): List<Class> =
-        getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) { true }
-            .filterIsInstance<ClassDescriptor>()
-            .map { visitClassDescriptor(it, parent) }
-
-    private fun DeclarationDescriptor.resolveDescriptorData(): PlatformInfo {
-        val doc = findKDoc()
-        val links = doc?.children?.filter { it is KDocLink }?.flatMap { link ->
-            val destination = link.children.first { it is KDocName }.text
-            resolveKDocLink(
-                resolutionFacade.resolveSession.bindingContext,
-                resolutionFacade,
-                this,
-                null,
-                destination.split('.')
-            ).map { Pair(destination, DRI.from(it)) }
-        }?.toMap() ?: emptyMap()
-        return BasePlatformInfo(doc, links, listOf(platformData))
-    }
-
-    private fun ClassDescriptor.resolveClassDescriptionData(): ClassPlatformInfo {
-        return ClassPlatformInfo(resolveDescriptorData(),
-            (getSuperInterfaces() + getAllSuperclassesWithoutAny()).map { DRI.from(it) })
-    }
-
-    private fun getXMLDRIs(descriptor: DeclarationDescriptor, platformInfo: PlatformInfo?) =
-        platformInfo?.docTag?.children
-            ?.filter {
-                it.text.contains("@attr")
-            }?.flatMap { ref ->
-                val matchResult = "@attr\\s+ref\\s+(.+)".toRegex().matchEntire(ref.text)
-                val toFind = matchResult?.groups?.last()?.value.orEmpty()
-                resolveKDocLink(
-                    resolutionFacade.resolveSession.bindingContext,
-                    resolutionFacade,
-                    descriptor,
-                    null,
-                    toFind.split('.')
-                ).map { XMLMega("@attr ref", DRI.from(it)) }
-            }.orEmpty()
-}
-
-data class XMLMega(val key: String, val dri: DRI) : Extra
-
-enum class KotlinClassKindTypes : ClassKind {
-    CLASS,
-    INTERFACE,
-    ENUM_CLASS,
-    ENUM_ENTRY,
-    ANNOTATION_CLASS,
-    OBJECT;
-}
-
-class KotlinTypeWrapper(private val kotlinType: KotlinType) : TypeWrapper {
-    private val declarationDescriptor = kotlinType.constructor.declarationDescriptor
-    private val fqNameSafe = declarationDescriptor?.fqNameSafe
-    override val constructorFqName = fqNameSafe?.asString()
-    override val constructorNamePathSegments: List<String> =
-        fqNameSafe?.pathSegments()?.map { it.asString() } ?: emptyList()
-    override val arguments: List<KotlinTypeWrapper> by lazy { kotlinType.arguments.map { KotlinTypeWrapper(it.type) } }
-    override val dri: DRI? by lazy { declarationDescriptor?.let { DRI.from(it) } }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 05eb3054..b6bf7a73 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,20 +1,24 @@
 package org.jetbrains.dokka
 
 import org.jetbrains.dokka.Model.Module
-import org.jetbrains.dokka.Model.transformers.DocumentationNodesMerger
 import org.jetbrains.dokka.Utilities.pretty
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.MarkdownToContentConverter
+import org.jetbrains.dokka.pages.DefaultMarkdownToContentConverter
 import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProvider
-import org.jetbrains.dokka.transformers.DefaultDocumentationToPageTransformer
+import org.jetbrains.dokka.resolvers.LocationProvider
+import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
+import org.jetbrains.dokka.transformers.descriptors.DokkaDescriptorVisitor
+import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 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.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 
@@ -22,56 +26,131 @@ class DokkaGenerator(
     private val configuration: DokkaConfiguration,
     private val logger: DokkaLogger
 ) {
-    fun generate(): Unit {
+
+    fun generate() {
+        logger.debug("Setting up analysis environments")
+        val platforms: Map<PlatformData, EnvironmentAndFacade> = configuration.passesConfigurations.map {
+            PlatformData(it.analysisPlatform, it.targets) to createEnvironmentAndFacade(it)
+        }.toMap()
 
         logger.debug("Initializing plugins")
-        val context = DokkaContext.create(configuration.pluginsClasspath, logger)
-
-        configuration.passesConfigurations.map { pass ->
-            AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
-                if (analysisPlatform == Platform.jvm) {
-                    addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
-                }
-                for (element in pass.classpath) {
-                    addClasspath(File(element))
-                }
-
-                addSources(pass.sourceRoots.map { it.path })
-
-                loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
-
-                val environment = createCoreEnvironment()
-                val (facade, _) = createResolutionFacade(environment)
-
-                environment.getSourceFiles().asSequence()
-                    .map { it.packageFqName }
-                    .distinct()
-                    .mapNotNull { facade.resolveSession.getPackageFragment(it) }
-                    .map {
-                        DokkaDescriptorVisitor(
-                            PlatformData(pass.analysisPlatform, pass.targets),
-                            facade
-                        ).visitPackageFragmentDescriptor(
-                            it,
-                            DRI.topLevel
-                        )
-                    }
-                    .toList()
-                    .let { Module(it) }
-                    .let { DocumentationNodesMerger(it) }
-                    .also { println("${pass.analysisPlatform}:\n${it.pretty()}\n\n") }
+        val context = DokkaContext.create(configuration.pluginsClasspath, logger, platforms)
+
+        logger.debug("Creating documentation models")
+        val modulesFromPlatforms = platforms.map { (pdata, _) -> translateDescriptors(pdata, context) }
+
+        logger.debug("Merging documentation models")
+        val documentationModel = context.single(CoreExtensions.documentationMerger)
+            .invoke(modulesFromPlatforms, context)
+
+        logger.debug("Transforming documentation model")
+        val transformedDocumentation = context[CoreExtensions.documentationTransformer]
+            .fold(documentationModel) { acc, t -> t(acc, context) }
+
+        logger.debug("Creating pages")
+        val pages = context.single(CoreExtensions.documentationToPageTranslator)
+            .invoke(transformedDocumentation, context)
+
+        logger.debug("Transforming pages")
+        val transformedPages = context[CoreExtensions.pageTransformer]
+            .fold(pages) { acc, t -> t(acc, context) }
+
+        logger.debug("Rendering")
+        val fileWriter = FileWriter(configuration.outputDir, "")
+        val locationProvider = context.single(CoreExtensions.locationProvider)
+            .invoke(transformedPages, configuration, context)
+        val renderer = context.single(CoreExtensions.renderer)
+            .invoke(fileWriter, locationProvider, context)
+
+        renderer.render(transformedPages)
+    }
+
+//    fun generate(int: Int) {
+//
+//        logger.debug("Initializing plugins")
+//        val context = DokkaContext.create(configuration.pluginsClasspath, logger, platforms)
+//
+//        configuration.passesConfigurations.map { pass ->
+//            AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
+//                if (analysisPlatform == Platform.jvm) {
+//                    addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
+//                }
+//                for (element in pass.classpath) {
+//                    addClasspath(File(element))
+//                }
+//
+//                addSources(pass.sourceRoots.map { it.path })
+//
+//                loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
+//
+//                val environment = createCoreEnvironment()
+//                val (facade, _) = createResolutionFacade(environment)
+//
+//                environment.getSourceFiles().asSequence()
+//                        .map { it.packageFqName }
+//                        .distinct()
+//                        .mapNotNull { facade.resolveSession.getPackageFragment(it) }
+//                        .map {
+//                        DokkaDescriptorVisitor(
+//                            PlatformData(
+//                                pass.analysisPlatform,
+//                                pass.targets
+//                            ), facade
+//                        )
+//                            .visitPackageFragmentDescriptor(it, DRI.topLevel)
+//                    }
+//                    .toList()
+//                    .let { Module(it) }
+//                    .let { DefaultDocumentationNodeMerger(it) }
+//                    .also { println("${pass.analysisPlatform}:\n${it.pretty()}\n\n") }
+//            }
+//        }.let {
+//            val markdownConverter = DefaultMarkdownToContentConverter(logger)
+//            DefaultDocumentationToPageTranslator(
+//                markdownConverter,
+//                logger
+//            ).transform(
+//                DefaultDocumentationNodeMerger(
+//                    it
+//                )
+//            )
+//        }.let {
+//            context[CoreExtensions.pageTransformer].fold(it) { pn, t -> t(pn, context) }
+//        }.also {
+//            HtmlRenderer(
+//                FileWriter(configuration.outputDir, ""),
+//                DefaultLocationProvider(it, configuration, ".${configuration.format}")
+//            ).render(it)
+//        }
+//    }
+
+    private fun createEnvironmentAndFacade(pass: DokkaConfiguration.PassConfiguration): EnvironmentAndFacade =
+        AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
+            if (analysisPlatform == Platform.jvm) {
+                addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
             }
-        }.let {
-            val markdownConverter = MarkdownToContentConverter(logger)
-            DefaultDocumentationToPageTransformer(markdownConverter, logger).transform(DocumentationNodesMerger(it))
-        }.let {
-            context[CoreExtensions.pageTransformer].fold(it) { pn, t -> t.action.invoke(pn, context) }
-        }.also {
-            HtmlRenderer(
-                FileWriter(configuration.outputDir, ""),
-                DefaultLocationProvider(it, configuration, ".${configuration.format}")
-            ).render(it)
+            pass.classpath.forEach { addClasspath(File(it)) }
+
+            addSources(pass.sourceRoots.map { it.path })
+
+            loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
+
+            val environment = createCoreEnvironment()
+            val (facade, _) = createResolutionFacade(environment)
+            EnvironmentAndFacade(environment, facade)
         }
+
+    private fun translateDescriptors(platformData: PlatformData, context: DokkaContext): Module {
+        val (environment, facade) = context.platforms.getValue(platformData)
+
+        val packageFragments = environment.getSourceFiles().asSequence()
+            .map { it.packageFqName }
+            .distinct()
+            .mapNotNull { facade.resolveSession.getPackageFragment(it) }
+            .toList()
+
+        return context.single(CoreExtensions.descriptorToDocumentationTranslator)
+            .invoke(packageFragments, platformData, context)
     }
 
     private class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
@@ -90,4 +169,10 @@ class DokkaGenerator(
 
         override fun hasErrors() = seenErrors
     }
+}
+
+// It is not data class due to ill-defined equals
+class EnvironmentAndFacade(val environment: KotlinCoreEnvironment, val facade: DokkaResolutionFacade) {
+    operator fun component1() = environment
+    operator fun component2() = facade
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 0adb37b5..b1d4be55 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.Model
 
-import org.jetbrains.dokka.KotlinTypeWrapper
+import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
diff --git a/core/src/main/kotlin/Model/transformers/DocumentationNodeTransformer.kt b/core/src/main/kotlin/Model/transformers/DocumentationNodeTransformer.kt
deleted file mode 100644
index 318d20b3..00000000
--- a/core/src/main/kotlin/Model/transformers/DocumentationNodeTransformer.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package org.jetbrains.dokka.Model.transformers
-
-import org.jetbrains.dokka.Model.Module
-
-interface DocumentationNodeTransformer {
-    operator fun invoke(original: Module): Module
-    operator fun invoke(modules: Collection<Module>): Module
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Model/transformers/DocumentationNodesMerger.kt b/core/src/main/kotlin/Model/transformers/DocumentationNodesMerger.kt
deleted file mode 100644
index ae4f8d99..00000000
--- a/core/src/main/kotlin/Model/transformers/DocumentationNodesMerger.kt
+++ /dev/null
@@ -1,90 +0,0 @@
-package org.jetbrains.dokka.Model.transformers
-
-import org.jetbrains.dokka.Model.*
-import org.jetbrains.dokka.Model.Function
-
-internal object DocumentationNodesMerger : DocumentationNodeTransformer {
-    override fun invoke(original: Module) = Module(
-        original.packages.map { mergePackageContent(it) }
-    )
-    override fun invoke(modules: Collection<Module>): Module =
-        Module(merge(modules.flatMap { it.packages }, Package::mergeWith))
-}
-
-private fun mergePackageContent(original: Package) = Package(
-    original.dri,
-    merge(original.functions, Function::mergeWith),
-    merge(original.properties, Property::mergeWith),
-    merge(original.classes, Class::mergeWith)
-)
-
-private fun <T: DocumentationNode> merge(elements: List<T>, reducer: (T, T) -> T): List<T> =
-    elements.groupingBy { it.dri }
-        .reduce { _, left, right -> reducer(left, right)}
-        .values.toList()
-
-fun PlatformInfo.mergeWith(other: PlatformInfo?) = BasePlatformInfo(
-    docTag,
-    links,
-    (platformData + (other?.platformData ?: emptyList())).distinct()
-)
-
-fun ClassPlatformInfo.mergeWith(other: ClassPlatformInfo?) = ClassPlatformInfo(
-    info.mergeWith(other?.info),
-    (inherited + (other?.inherited ?: emptyList())).distinct()
-)
-
-fun List<ClassPlatformInfo>.mergeClassPlatformInfo() : List<ClassPlatformInfo> =
-    groupingBy { it.docTag.toString() + it.links + it.inherited}.reduce {
-            _, left, right -> left.mergeWith(right)
-    }.values.toList()
-
-fun List<PlatformInfo>.merge() : List<PlatformInfo> =
-    groupingBy { it.docTag.toString() + it.links }.reduce {
-        _, left, right -> left.mergeWith(right)
-    }.values.toList()
-
-fun Function.mergeWith(other: Function) = Function(
-    dri,
-    name,
-    returnType,
-    isConstructor,
-    if (receiver != null && other.receiver != null) receiver.mergeWith(other.receiver) else null,
-    merge(parameters + other.parameters, Parameter::mergeWith),
-    expected?.mergeWith(other.expected),
-    (actual + other.actual).merge()
-)
-
-fun Property.mergeWith(other: Property) = Property(
-    dri,
-    name,
-    if (receiver != null && other.receiver != null) receiver.mergeWith(other.receiver) else null,
-    expected?.mergeWith(other.expected),
-    (actual + other.actual).merge()
-)
-
-fun Class.mergeWith(other: Class) = Class(
-    dri,
-    name,
-    kind,
-    merge(constructors + other.constructors, Function::mergeWith),
-    merge(functions + other.functions, Function::mergeWith),
-    merge(properties + other.properties, Property::mergeWith),
-    merge(classes + other.classes, Class::mergeWith),
-    expected?.mergeWith(other.expected),
-    (actual + other.actual).mergeClassPlatformInfo()
-)
-
-fun Parameter.mergeWith(other: Parameter) = Parameter(
-    dri,
-    name,
-    type,
-    (actual + other.actual).merge()
-)
-
-fun Package.mergeWith(other: Package) = Package(
-    dri,
-    merge(functions + other.functions, Function::mergeWith),
-    merge(properties + other.properties, Property::mergeWith),
-    merge(classes + other.classes, Class::mergeWith)
-)
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt b/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
new file mode 100644
index 00000000..72b5ead2
--- /dev/null
+++ b/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
@@ -0,0 +1,229 @@
+package org.jetbrains.dokka.pages
+
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.jetbrains.dokka.MarkdownNode
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.plugability.DokkaContext
+
+class DefaultMarkdownToContentConverter(
+    private val context: DokkaContext
+) : MarkdownToContentConverter {
+    override fun buildContent(
+        node: MarkdownNode,
+        dci: DCI,
+        platforms: Set<PlatformData>,
+        links: Map<String, DRI>,
+        styles: Set<Style>,
+        extras: Set<Extra>
+
+    ): List<ContentNode> {
+//    println(tree.toTestString())
+
+        fun buildChildren(node: MarkdownNode, newStyles: Set<Style> = emptySet(), newExtras: Set<Extra> = emptySet()) =
+            node.children.flatMap {
+                buildContent(it, dci, platforms, links, styles + newStyles, extras + newExtras)
+            }.coalesceText(platforms, styles + newStyles, extras + newExtras)
+
+        fun buildHeader(level: Int) =
+            ContentHeader(buildChildren(node), level, dci, platforms, styles)
+
+        return when (node.type) {
+            MarkdownElementTypes.ATX_1 -> listOf(buildHeader(1))
+            MarkdownElementTypes.ATX_2 -> listOf(buildHeader(2))
+            MarkdownElementTypes.ATX_3 -> listOf(buildHeader(3))
+            MarkdownElementTypes.ATX_4 -> listOf(buildHeader(4))
+            MarkdownElementTypes.ATX_5 -> listOf(buildHeader(5))
+            MarkdownElementTypes.ATX_6 -> listOf(buildHeader(6))
+            MarkdownElementTypes.UNORDERED_LIST -> listOf(
+                ContentList(
+                    buildChildren(node),
+                    false,
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            MarkdownElementTypes.ORDERED_LIST -> listOf(
+                ContentList(
+                    buildChildren(node),
+                    true,
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            MarkdownElementTypes.LIST_ITEM -> TODO()
+            MarkdownElementTypes.STRONG,
+            MarkdownTokenTypes.EMPH,
+            MarkdownElementTypes.EMPH ->
+                buildChildren(node, setOf(TextStyle.Strong))
+            // TODO
+            MarkdownElementTypes.CODE_SPAN -> TODO()
+//            val startDelimiter = node.child(MarkdownTokenTypes.BACKTICK)?.text
+//            if (startDelimiter != null) {
+//                val text = node.text.substring(startDelimiter.length).removeSuffix(startDelimiter)
+//                val codeSpan = ContentCode().apply { append(ContentText(text)) }
+//                parent.append(codeSpan)
+//            }
+
+            MarkdownElementTypes.CODE_BLOCK,
+            MarkdownElementTypes.CODE_FENCE -> {
+                val language = node.child(MarkdownTokenTypes.FENCE_LANG)?.text?.trim() ?: ""
+                listOf(ContentCode(buildChildren(node), language, dci, platforms, styles, extras)) // TODO
+            }
+            MarkdownElementTypes.PARAGRAPH -> buildChildren(node, newStyles = setOf(TextStyle.Paragraph))
+
+            MarkdownElementTypes.INLINE_LINK -> {
+//            val linkTextNode = node.child(MarkdownElementTypes.LINK_TEXT)
+//            val destination = node.child(MarkdownElementTypes.LINK_DESTINATION)
+//            if (linkTextNode != null) {
+//                if (destination != null) {
+//                    val link = ContentExternalLink(destination.text)
+//                    renderLinkTextTo(linkTextNode, link, linkResolver)
+//                    parent.append(link)
+//                } else {
+//                    val link = ContentExternalLink(linkTextNode.getLabelText())
+//                    renderLinkTextTo(linkTextNode, link, linkResolver)
+//                    parent.append(link)
+//                }
+//            }
+                //TODO: Linking!!!
+//            ContentLink()
+                TODO()
+            }
+            MarkdownElementTypes.SHORT_REFERENCE_LINK,
+            MarkdownElementTypes.FULL_REFERENCE_LINK -> {
+                val destinationNode = node.children.find { it.type == MarkdownElementTypes.LINK_DESTINATION }
+                        ?: node.children.first { it.type == MarkdownElementTypes.LINK_LABEL }
+                val destination = destinationNode.children.find { it.type == MarkdownTokenTypes.TEXT }?.text
+                        ?: destinationNode.text
+                links[destination]?.let { dri ->
+                    listOf(
+                        ContentResolvedLink(
+                            buildChildren(node),
+                            destination,
+                            DCI(dri, ContentKind.Symbol),
+                            platforms,
+                            styles,
+                            extras
+                        )
+                    )
+                } ?: let {
+                    context.logger.error("Apparently there is no link resolved for $destination")
+                    emptyList<ContentNode>()
+                }
+            }
+            MarkdownTokenTypes.WHITE_SPACE -> {
+                // Don't append first space if start of header (it is added during formatting later)
+                //                   v
+                //               #### Some Heading
+//            if (nodeStack.peek() !is ContentHeading || node.parent?.children?.first() != node) {
+//                parent.append(ContentText(node.text))
+//            }
+                listOf(ContentText(" ", dci, platforms, styles, extras))
+            }
+            MarkdownTokenTypes.EOL -> {
+//            if ((keepEol(nodeStack.peek()) && node.parent?.children?.last() != node) ||
+//                // Keep extra blank lines when processing lists (affects Markdown formatting)
+//                (processingList(nodeStack.peek()) && node.previous?.type == MarkdownTokenTypes.EOL)) {
+//                parent.append(ContentText(node.text))
+//            }
+                listOf(ContentText(" ", dci, platforms, styles, extras))
+            }
+
+            MarkdownTokenTypes.CODE_LINE -> {
+                listOf(ContentText(node.text, dci, platforms, styles, extras)) // TODO check
+//            if (parent is ContentBlockCode) {
+//                parent.append(content)
+//            } else {
+//                parent.append(ContentBlockCode().apply { append(content) })
+//            }
+            }
+
+            MarkdownTokenTypes.TEXT ->
+//            fun createEntityOrText(text: String): ContentNode {
+//                if (text == "&amp;" || text == "&quot;" || text == "&lt;" || text == "&gt;") {
+//                    return ContentEntity(text)
+//                }
+//                if (text == "&") {
+//                    return ContentEntity("&amp;")
+//                }
+//                val decodedText = EntityConverter.replaceEntities(text, true, true)
+//                if (decodedText != text) {
+//                    return ContentEntity(text)
+//                }
+//                return ContentText(text)
+//            }
+//
+//            parent.append(createEntityOrText(node.text))
+                listOf(ContentText(node.text, dci, platforms, styles, extras)) // TODO
+
+            MarkdownTokenTypes.COLON,
+            MarkdownTokenTypes.SINGLE_QUOTE,
+            MarkdownTokenTypes.DOUBLE_QUOTE,
+            MarkdownTokenTypes.LT,
+            MarkdownTokenTypes.GT,
+            MarkdownTokenTypes.LPAREN,
+            MarkdownTokenTypes.RPAREN,
+            MarkdownTokenTypes.LBRACKET,
+            MarkdownTokenTypes.RBRACKET,
+            MarkdownTokenTypes.EXCLAMATION_MARK,
+            MarkdownTokenTypes.BACKTICK,
+            MarkdownTokenTypes.CODE_FENCE_CONTENT -> {
+                listOf(ContentText(node.text, dci, platforms, styles, extras))
+            }
+
+            MarkdownElementTypes.LINK_DEFINITION -> TODO()
+
+            MarkdownTokenTypes.EMAIL_AUTOLINK ->
+                listOf(
+                    ContentResolvedLink(
+                        listOf(ContentText(node.text, dci, platforms, styles, extras)),
+                        "mailto:${node.text}",
+                        dci, platforms, styles, extras
+                    )
+                )
+
+            else -> buildChildren(node)
+        }
+    }
+
+    private fun Collection<ContentNode>.coalesceText(
+        platforms: Set<PlatformData>,
+        styles: Set<Style>,
+        extras: Set<Extra>
+    ) =
+        this
+            .sliceWhen { prev, next -> prev::class != next::class }
+            .flatMap { nodes ->
+                when (nodes.first()) {
+                    is ContentText -> listOf(
+                        ContentText(
+                            nodes.joinToString("") { (it as ContentText).text },
+                            nodes.first().dci, platforms, styles, extras
+                        )
+                    )
+                    else -> nodes
+                }
+            }
+}
+
+fun <T> Collection<T>.sliceWhen(predicate: (before: T, after: T) -> Boolean): Collection<Collection<T>> {
+    val newCollection = mutableListOf<Collection<T>>()
+    var currentSlice = mutableListOf<T>()
+    for ((prev, next) in this.windowed(2, 1, false)) {
+        currentSlice.add(prev)
+        if (predicate(prev, next)) {
+            newCollection.add(currentSlice)
+            currentSlice = mutableListOf<T>()
+        }
+    }
+    if (this.isNotEmpty()) {
+        currentSlice.add(this.last())
+        newCollection.add(currentSlice)
+    }
+    return newCollection
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
index 8caddeb0..fe4736b7 100644
--- a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
+++ b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
@@ -1,14 +1,10 @@
 package org.jetbrains.dokka.pages
 
-import org.intellij.markdown.MarkdownElementTypes
-import org.intellij.markdown.MarkdownTokenTypes
-import org.jetbrains.dokka.DokkaLogger
 import org.jetbrains.dokka.MarkdownNode
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.plugability.DokkaContext
 
-class MarkdownToContentConverter(
-    private val logger: DokkaLogger
-) {
+interface MarkdownToContentConverter {
     fun buildContent(
         node: MarkdownNode,
         dci: DCI,
@@ -16,214 +12,5 @@ class MarkdownToContentConverter(
         links: Map<String, DRI> = emptyMap(),
         styles: Set<Style> = emptySet(),
         extras: Set<Extra> = emptySet()
-
-    ): List<ContentNode> {
-//    println(tree.toTestString())
-
-        fun buildChildren(node: MarkdownNode, newStyles: Set<Style> = emptySet(), newExtras: Set<Extra> = emptySet()) =
-            node.children.flatMap {
-                buildContent(it, dci, platforms, links, styles + newStyles, extras + newExtras)
-            }.coalesceText(platforms, styles + newStyles, extras + newExtras)
-
-        fun buildHeader(level: Int) =
-            ContentHeader(buildChildren(node), level, dci, platforms, styles)
-
-        return when (node.type) {
-            MarkdownElementTypes.ATX_1 -> listOf(buildHeader(1))
-            MarkdownElementTypes.ATX_2 -> listOf(buildHeader(2))
-            MarkdownElementTypes.ATX_3 -> listOf(buildHeader(3))
-            MarkdownElementTypes.ATX_4 -> listOf(buildHeader(4))
-            MarkdownElementTypes.ATX_5 -> listOf(buildHeader(5))
-            MarkdownElementTypes.ATX_6 -> listOf(buildHeader(6))
-            MarkdownElementTypes.UNORDERED_LIST -> listOf(
-                ContentList(
-                    buildChildren(node),
-                    false,
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            MarkdownElementTypes.ORDERED_LIST -> listOf(
-                ContentList(
-                    buildChildren(node),
-                    true,
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            MarkdownElementTypes.LIST_ITEM -> TODO()
-            MarkdownElementTypes.STRONG,
-            MarkdownTokenTypes.EMPH,
-            MarkdownElementTypes.EMPH ->
-                buildChildren(node, setOf(TextStyle.Strong))
-            // TODO
-            MarkdownElementTypes.CODE_SPAN -> TODO()
-//            val startDelimiter = node.child(MarkdownTokenTypes.BACKTICK)?.text
-//            if (startDelimiter != null) {
-//                val text = node.text.substring(startDelimiter.length).removeSuffix(startDelimiter)
-//                val codeSpan = ContentCode().apply { append(ContentText(text)) }
-//                parent.append(codeSpan)
-//            }
-
-            MarkdownElementTypes.CODE_BLOCK,
-            MarkdownElementTypes.CODE_FENCE -> {
-                val language = node.child(MarkdownTokenTypes.FENCE_LANG)?.text?.trim() ?: ""
-                listOf(ContentCode(buildChildren(node), language, dci, platforms, styles, extras)) // TODO
-            }
-            MarkdownElementTypes.PARAGRAPH -> buildChildren(node, newStyles = setOf(TextStyle.Paragraph))
-
-            MarkdownElementTypes.INLINE_LINK -> {
-//            val linkTextNode = node.child(MarkdownElementTypes.LINK_TEXT)
-//            val destination = node.child(MarkdownElementTypes.LINK_DESTINATION)
-//            if (linkTextNode != null) {
-//                if (destination != null) {
-//                    val link = ContentExternalLink(destination.text)
-//                    renderLinkTextTo(linkTextNode, link, linkResolver)
-//                    parent.append(link)
-//                } else {
-//                    val link = ContentExternalLink(linkTextNode.getLabelText())
-//                    renderLinkTextTo(linkTextNode, link, linkResolver)
-//                    parent.append(link)
-//                }
-//            }
-                //TODO: Linking!!!
-//            ContentLink()
-                TODO()
-            }
-            MarkdownElementTypes.SHORT_REFERENCE_LINK,
-            MarkdownElementTypes.FULL_REFERENCE_LINK -> {
-                val destinationNode = node.children.find { it.type == MarkdownElementTypes.LINK_DESTINATION }
-                        ?: node.children.first { it.type == MarkdownElementTypes.LINK_LABEL }
-                val destination = destinationNode.children.find { it.type == MarkdownTokenTypes.TEXT }?.text
-                        ?: destinationNode.text
-                links[destination]?.let { dri ->
-                    listOf(
-                        ContentResolvedLink(
-                            buildChildren(node),
-                            destination,
-                            DCI(dri, ContentKind.Symbol),
-                            platforms,
-                            styles,
-                            extras
-                        )
-                    )
-                } ?: let {
-                    logger.error("Apparently there is no link resolved for $destination")
-                    emptyList<ContentNode>()
-                }
-            }
-            MarkdownTokenTypes.WHITE_SPACE -> {
-                // Don't append first space if start of header (it is added during formatting later)
-                //                   v
-                //               #### Some Heading
-//            if (nodeStack.peek() !is ContentHeading || node.parent?.children?.first() != node) {
-//                parent.append(ContentText(node.text))
-//            }
-                listOf(ContentText(" ", dci, platforms, styles, extras))
-            }
-            MarkdownTokenTypes.EOL -> {
-//            if ((keepEol(nodeStack.peek()) && node.parent?.children?.last() != node) ||
-//                // Keep extra blank lines when processing lists (affects Markdown formatting)
-//                (processingList(nodeStack.peek()) && node.previous?.type == MarkdownTokenTypes.EOL)) {
-//                parent.append(ContentText(node.text))
-//            }
-                listOf(ContentText(" ", dci, platforms, styles, extras))
-            }
-
-            MarkdownTokenTypes.CODE_LINE -> {
-                listOf(ContentText(node.text, dci, platforms, styles, extras)) // TODO check
-//            if (parent is ContentBlockCode) {
-//                parent.append(content)
-//            } else {
-//                parent.append(ContentBlockCode().apply { append(content) })
-//            }
-            }
-
-            MarkdownTokenTypes.TEXT ->
-//            fun createEntityOrText(text: String): ContentNode {
-//                if (text == "&amp;" || text == "&quot;" || text == "&lt;" || text == "&gt;") {
-//                    return ContentEntity(text)
-//                }
-//                if (text == "&") {
-//                    return ContentEntity("&amp;")
-//                }
-//                val decodedText = EntityConverter.replaceEntities(text, true, true)
-//                if (decodedText != text) {
-//                    return ContentEntity(text)
-//                }
-//                return ContentText(text)
-//            }
-//
-//            parent.append(createEntityOrText(node.text))
-                listOf(ContentText(node.text, dci, platforms, styles, extras)) // TODO
-
-            MarkdownTokenTypes.COLON,
-            MarkdownTokenTypes.SINGLE_QUOTE,
-            MarkdownTokenTypes.DOUBLE_QUOTE,
-            MarkdownTokenTypes.LT,
-            MarkdownTokenTypes.GT,
-            MarkdownTokenTypes.LPAREN,
-            MarkdownTokenTypes.RPAREN,
-            MarkdownTokenTypes.LBRACKET,
-            MarkdownTokenTypes.RBRACKET,
-            MarkdownTokenTypes.EXCLAMATION_MARK,
-            MarkdownTokenTypes.BACKTICK,
-            MarkdownTokenTypes.CODE_FENCE_CONTENT -> {
-                listOf(ContentText(node.text, dci, platforms, styles, extras))
-            }
-
-            MarkdownElementTypes.LINK_DEFINITION -> TODO()
-
-            MarkdownTokenTypes.EMAIL_AUTOLINK ->
-                listOf(
-                    ContentResolvedLink(
-                        listOf(ContentText(node.text, dci, platforms, styles, extras)),
-                        "mailto:${node.text}",
-                        dci, platforms, styles, extras
-                    )
-                )
-
-            else -> buildChildren(node)
-        }
-    }
-
-    private fun Collection<ContentNode>.coalesceText(
-        platforms: Set<PlatformData>,
-        styles: Set<Style>,
-        extras: Set<Extra>
-    ) =
-        this
-            .sliceWhen { prev, next -> prev::class != next::class }
-            .flatMap { nodes ->
-                when (nodes.first()) {
-                    is ContentText -> listOf(
-                        ContentText(
-                            nodes.joinToString("") { (it as ContentText).text },
-                            nodes.first().dci, platforms, styles, extras
-                        )
-                    )
-                    else -> nodes
-                }
-            }
+    ): List<ContentNode>
 }
-
-fun <T> Collection<T>.sliceWhen(predicate: (before: T, after: T) -> Boolean): Collection<Collection<T>> {
-    val newCollection = mutableListOf<Collection<T>>()
-    var currentSlice = mutableListOf<T>()
-    for ((prev, next) in this.windowed(2, 1, false)) {
-        currentSlice.add(prev)
-        if (predicate(prev, next)) {
-            newCollection.add(currentSlice)
-            currentSlice = mutableListOf<T>()
-        }
-    }
-    if (this.isNotEmpty()) {
-        currentSlice.add(this.last())
-        newCollection.add(currentSlice)
-    }
-    return newCollection
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/transformers/PageNodeTransformer.kt b/core/src/main/kotlin/pages/transformers/PageNodeTransformer.kt
deleted file mode 100644
index 0d0f8057..00000000
--- a/core/src/main/kotlin/pages/transformers/PageNodeTransformer.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package org.jetbrains.dokka.pages.transformers
-
-import org.jetbrains.dokka.pages.ModulePageNode
-
-interface PageNodeTransformer {
-    operator fun invoke(original: ModulePageNode): ModulePageNode
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
new file mode 100644
index 00000000..dd656386
--- /dev/null
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.dokka.plugability
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.pages.DefaultMarkdownToContentConverter
+import org.jetbrains.dokka.renderers.DefaultRenderer
+import org.jetbrains.dokka.renderers.HtmlRenderer
+import org.jetbrains.dokka.resolvers.DefaultLocationProvider
+import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
+import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
+import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
+
+object DefaultExtensions : DokkaExtensionHandler {
+    @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
+    override fun <T : Any, E : ExtensionPoint<T>> get(point: E, askDefault: AskDefault): List<T> =
+        when (point) {
+            CoreExtensions.descriptorToDocumentationTranslator -> DefaultDescriptorToDocumentationTranslator
+            CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
+            CoreExtensions.markdownToContentConverterFactory -> ::DefaultMarkdownToContentConverter
+            CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
+            CoreExtensions.renderer -> ::HtmlRenderer
+            CoreExtensions.locationProvider -> ::DefaultLocationProvider
+            CoreExtensions.fileExtension -> ".html"
+            else -> null
+        }.let { listOfNotNull(it) as List<T> }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index b917ff99..31c56728 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,23 +1,35 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.DokkaLogger
+import org.jetbrains.dokka.EnvironmentAndFacade
+import org.jetbrains.dokka.pages.PlatformData
 import java.io.File
 import java.net.URLClassLoader
 import java.util.*
 import kotlin.reflect.KClass
 import kotlin.reflect.full.createInstance
 
-interface DokkaContext {
-    operator fun <T, E> get(point: E, askDefault: AskDefault = AskDefault.WhenEmpty): List<Extension<T>>
+
+interface DokkaExtensionHandler {
+    operator fun <T, E> get(point: E, askDefault: AskDefault = AskDefault.WhenEmpty): List<T>
             where T : Any, E : ExtensionPoint<T>
 
+}
+
+interface DokkaContext : DokkaExtensionHandler {
     fun <T : DokkaPlugin> plugin(kclass: KClass<T>): T?
 
     val logger: DokkaLogger
 
+    val platforms: Map<PlatformData, EnvironmentAndFacade>
+
     companion object {
-        fun create(pluginsClasspath: Iterable<File>, logger: DokkaLogger): DokkaContext =
-            DokkaContextConfigurationImpl(logger, DefaultContext(logger)).apply {
+        fun create(
+            pluginsClasspath: Iterable<File>,
+            logger: DokkaLogger,
+            platforms: Map<PlatformData, EnvironmentAndFacade>
+        ): DokkaContext =
+            DokkaContextConfigurationImpl(logger, DefaultExtensions, platforms).apply {
                 pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
                     .toTypedArray()
                     .let { URLClassLoader(it, this.javaClass.classLoader) }
@@ -28,13 +40,27 @@ interface DokkaContext {
     }
 }
 
+fun <T, E> DokkaContext.single(point: E): T where T : Any, E : ExtensionPoint<T> {
+    fun throwBadArity(substitution: String): Nothing = throw IllegalStateException(
+        "$point was expected to have exactly one extension registered, but $substitution found."
+    )
+
+    val extensions = get(point, AskDefault.WhenEmpty)
+    return when (extensions.size) {
+        0 -> throwBadArity("none was")
+        1 -> extensions.first()
+        else -> throwBadArity("multiple were")
+    }
+}
+
 interface DokkaContextConfiguration {
     fun addExtension(extension: Extension<*>)
 }
 
 private class DokkaContextConfigurationImpl(
     override val logger: DokkaLogger,
-    private val defaultContext: DokkaContext?
+    private val defaultHandler: DokkaExtensionHandler?,
+    override val platforms: Map<PlatformData, EnvironmentAndFacade>
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
 
@@ -45,15 +71,16 @@ private class DokkaContextConfigurationImpl(
     @Suppress("UNCHECKED_CAST")
     override operator fun <T, E> get(point: E, askDefault: AskDefault) where T : Any, E : ExtensionPoint<T> =
         when (askDefault) {
-            AskDefault.Never -> extensions[point].orEmpty()
-            AskDefault.Always -> extensions[point].orEmpty() + defaultContext?.get(point, askDefault).orEmpty()
+            AskDefault.Never -> actions(point).orEmpty()
+            AskDefault.Always -> actions(point).orEmpty() + defaultHandler?.get(point, askDefault).orEmpty()
             AskDefault.WhenEmpty ->
-                extensions[point]?.takeIf { it.isNotEmpty() } ?: defaultContext?.get(point, askDefault).orEmpty()
-        } as List<Extension<T>>
+                actions(point)?.takeIf { it.isNotEmpty() } ?: defaultHandler?.get(point, askDefault).orEmpty()
+        } as List<T>
+
+    private fun <E : ExtensionPoint<*>> actions(point: E) = extensions[point]?.map { it.action }
 
     @Suppress("UNCHECKED_CAST")
-    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>) =
-        (plugins[kclass] ?: defaultContext?.plugin(kclass) ?: pluginStubFor(kclass)) as T
+    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>) = (plugins[kclass] ?: pluginStubFor(kclass)) as T
 
     private fun <T : DokkaPlugin> pluginStubFor(kclass: KClass<T>): DokkaPlugin =
         pluginStubs.getOrPut(kclass) { kclass.createInstance().also { it.context = this } }
@@ -69,7 +96,7 @@ private class DokkaContextConfigurationImpl(
     }
 
     fun logInitialisationInfo() {
-        val pluginNames: List<String> = plugins.values.map { it::class.qualifiedName.toString() }
+        val pluginNames = plugins.values.map { it::class.qualifiedName.toString() }
 
         val loadedListForDebug = extensions.run { keys + values.flatten() }.toList()
             .joinToString(prefix = "[\n", separator = ",\n", postfix = "\n]") { "\t$it" }
@@ -89,16 +116,6 @@ private fun checkClasspath(classLoader: URLClassLoader) {
     }
 }
 
-class DefaultContext(override val logger: DokkaLogger) : DokkaContext {
-    override fun <T : Any, E : ExtensionPoint<T>> get(point: E, askDefault: AskDefault): List<Extension<T>> =
-        when (point) {
-
-            else -> emptyList()
-        }
-
-    override fun <T : DokkaPlugin> plugin(kclass: KClass<T>): Nothing? = null
-}
-
 enum class AskDefault {
     Always, Never, WhenEmpty
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index c1573e1a..3039cb5a 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -11,7 +11,7 @@ class Extension<T : Any> internal constructor(
     internal val extensionPoint: ExtensionPoint<T>,
     internal val pluginClass: String,
     internal val extensionName: String,
-    internal val action: T,
+    val action: T,
     internal val ordering: (OrderDsl.() -> Unit)? = null
 ) {
     override fun toString() = "Extension: $pluginClass/$extensionName"
diff --git a/core/src/main/kotlin/renderers/DefaultRenderer.kt b/core/src/main/kotlin/renderers/DefaultRenderer.kt
index 3b16c093..3f851849 100644
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/core/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -1,9 +1,14 @@
 package org.jetbrains.dokka.renderers
 
 import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.resolvers.LocationProvider
 
-abstract class DefaultRenderer(val fileWriter: FileWriter, val locationProvider: LocationProvider) : Renderer {
+abstract class DefaultRenderer(
+    protected val fileWriter: FileWriter,
+    protected val locationProvider: LocationProvider,
+    protected val context: DokkaContext
+) : Renderer {
 
     protected abstract fun buildHeader(level: Int, text: String): String
     protected abstract fun buildLink(text: String, address: String): String
diff --git a/core/src/main/kotlin/renderers/HtmlRenderer.kt b/core/src/main/kotlin/renderers/HtmlRenderer.kt
index 3b778671..46548699 100644
--- a/core/src/main/kotlin/renderers/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/HtmlRenderer.kt
@@ -2,13 +2,18 @@ package org.jetbrains.dokka.renderers
 
 import org.jetbrains.dokka.htmlEscape
 import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.resolvers.LocationProvider
 import java.io.File
 import java.net.URL
 import java.nio.file.Path
 import java.nio.file.Paths
 
-open class HtmlRenderer(fileWriter: FileWriter, locationProvider: LocationProvider) : DefaultRenderer(fileWriter, locationProvider) {
+open class HtmlRenderer(
+    fileWriter: FileWriter,
+    locationProvider: LocationProvider,
+    context: DokkaContext
+) : DefaultRenderer(fileWriter, locationProvider, context) {
 
     override fun buildList(node: ContentList, pageContext: PageNode): String = if (node.ordered) {
         "<ol>${buildListItems(node.children, pageContext)}</ol>"
diff --git a/core/src/main/kotlin/renderers/Renderer.kt b/core/src/main/kotlin/renderers/Renderer.kt
index 24e01cdb..91483a46 100644
--- a/core/src/main/kotlin/renderers/Renderer.kt
+++ b/core/src/main/kotlin/renderers/Renderer.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.dokka.renderers
 
 import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.plugability.DokkaContext
 
 interface Renderer {
     fun render(root: PageNode)
diff --git a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
index 208410fe..ec5aa29a 100644
--- a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
+++ b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
@@ -1,11 +1,20 @@
 package org.jetbrains.dokka.resolvers
 
+import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.htmlEscape
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.single
+
+open class DefaultLocationProvider(
+    private val pageGraphRoot: PageNode,
+    private val configuration: DokkaConfiguration,
+    context: DokkaContext
+): LocationProvider { // TODO: cache
+    private val extension = context.single(CoreExtensions.fileExtension)
 
-open class DefaultLocationProvider(private val pageGraphRoot: PageNode, val configuration: DokkaConfiguration, val extension: String): LocationProvider { // TODO: cache
     override fun resolve(node: PageNode, context: PageNode?): String = pathTo(node, context) + extension
 
     override fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode?): String =
diff --git a/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt b/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
deleted file mode 100644
index b0877527..00000000
--- a/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-package org.jetbrains.dokka.transformers
-
-import org.jetbrains.dokka.DokkaLogger
-import org.jetbrains.dokka.Model.Module
-import org.jetbrains.dokka.pages.DefaultPageBuilder
-import org.jetbrains.dokka.pages.DefaultPageContentBuilder
-import org.jetbrains.dokka.pages.MarkdownToContentConverter
-import org.jetbrains.dokka.pages.ModulePageNode
-
-
-class DefaultDocumentationToPageTransformer(
-    private val markdownConverter: MarkdownToContentConverter,
-    private val logger: DokkaLogger
-) : DocumentationToPageTransformer {
-    override fun transform(module: Module): ModulePageNode =
-        DefaultPageBuilder { node, kind, operation ->
-            DefaultPageContentBuilder.group(node.dri, node.platformData, kind, markdownConverter, logger, operation)
-        }.pageForModule(module)
-
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/DocumentationToPageTransformer.kt b/core/src/main/kotlin/transformers/DocumentationToPageTransformer.kt
deleted file mode 100644
index 19703025..00000000
--- a/core/src/main/kotlin/transformers/DocumentationToPageTransformer.kt
+++ /dev/null
@@ -1,11 +0,0 @@
-package org.jetbrains.dokka.transformers
-
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.Model.DocumentationNode
-import org.jetbrains.dokka.Model.Module
-import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.pages.PageNode
-
-interface DocumentationToPageTransformer {
-    fun transform(module: Module): ModulePageNode // TODO refactor this... some more?
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/PageNodeTransformer.kt b/core/src/main/kotlin/transformers/PageNodeTransformer.kt
deleted file mode 100644
index b86e0b34..00000000
--- a/core/src/main/kotlin/transformers/PageNodeTransformer.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package org.jetbrains.dokka.transformers
-
-import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-
-interface PageNodeTransformer {
-    fun invoke(input: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
new file mode 100644
index 00000000..19aeef92
--- /dev/null
+++ b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
@@ -0,0 +1,208 @@
+package org.jetbrains.dokka.transformers.descriptors
+
+import org.jetbrains.dokka.DokkaResolutionFacade
+import org.jetbrains.dokka.Model.*
+import org.jetbrains.dokka.Model.ClassKind
+import org.jetbrains.dokka.Model.Function
+import org.jetbrains.dokka.links.Callable
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.links.withClass
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
+import org.jetbrains.kotlin.idea.kdoc.findKDoc
+import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
+import org.jetbrains.kotlin.kdoc.psi.impl.KDocLink
+import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
+import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.types.KotlinType
+
+object DefaultDescriptorToDocumentationTranslator: DescriptorToDocumentationTranslator {
+    override fun invoke(
+        packageFragments: Iterable<PackageFragmentDescriptor>,
+        platformData: PlatformData,
+        context: DokkaContext
+    ) = DokkaDescriptorVisitor(platformData, context.platforms[platformData]?.facade!!).run {
+        packageFragments.map { visitPackageFragmentDescriptor(it, DRI.topLevel) }
+    }.let { Module(it) }
+
+}
+
+class DokkaDescriptorVisitor(
+    private val platformData: PlatformData,
+    private val resolutionFacade: DokkaResolutionFacade
+) : DeclarationDescriptorVisitorEmptyBodies<DocumentationNode, DRI>() {
+    override fun visitDeclarationDescriptor(descriptor: DeclarationDescriptor, parent: DRI): Nothing {
+        throw IllegalStateException("${javaClass.simpleName} should never enter ${descriptor.javaClass.simpleName}")
+    }
+
+    override fun visitPackageFragmentDescriptor(
+        descriptor: PackageFragmentDescriptor,
+        parent: DRI
+    ): Package {
+        val dri = DRI(packageName = descriptor.fqName.asString())
+        val scope = descriptor.getMemberScope()
+        return Package(
+            dri,
+            scope.functions(dri),
+            scope.properties(dri),
+            scope.classes(dri)
+        )
+    }
+
+    override fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRI): Class {
+        val dri = parent.withClass(descriptor.name.asString())
+        val scope = descriptor.getMemberScope(emptyList())
+        val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
+        return Class(
+            dri,
+            descriptor.name.asString(),
+            KotlinClassKindTypes.valueOf(descriptor.kind.toString()),
+            descriptor.constructors.map { visitConstructorDescriptor(it, dri) },
+            scope.functions(dri),
+            scope.properties(dri),
+            scope.classes(dri),
+            descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData(),
+            listOfNotNull(descriptorData),
+            getXMLDRIs(descriptor, descriptorData).toMutableSet()
+        )
+    }
+
+    override fun visitPropertyDescriptor(descriptor: PropertyDescriptor, parent: DRI): Property {
+        val dri = parent.copy(callable = Callable.from(descriptor))
+        return Property(
+            dri,
+            descriptor.name.asString(),
+            descriptor.extensionReceiverParameter?.let { visitReceiverParameterDescriptor(it, dri) },
+            descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
+            listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
+        )
+    }
+
+    override fun visitFunctionDescriptor(descriptor: FunctionDescriptor, parent: DRI): Function {
+        val dri = parent.copy(callable = Callable.from(descriptor))
+        return Function(
+            dri,
+            descriptor.name.asString(),
+            descriptor.returnType?.let { KotlinTypeWrapper(it) },
+            false,
+            descriptor.extensionReceiverParameter?.let { visitReceiverParameterDescriptor(it, dri) },
+            descriptor.valueParameters.mapIndexed { index, desc -> parameter(index, desc, dri) },
+            descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
+            listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
+        )
+    }
+
+    override fun visitConstructorDescriptor(descriptor: ConstructorDescriptor, parent: DRI): Function {
+        val dri = parent.copy(callable = Callable.from(descriptor))
+        return Function(
+            dri,
+            "<init>",
+            KotlinTypeWrapper(descriptor.returnType),
+            true,
+            null,
+            descriptor.valueParameters.mapIndexed { index, desc -> parameter(index, desc, dri) },
+            descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
+            listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
+        )
+    }
+
+    override fun visitReceiverParameterDescriptor(
+        descriptor: ReceiverParameterDescriptor,
+        parent: DRI
+    ) = Parameter(
+        parent.copy(target = 0),
+        null,
+        KotlinTypeWrapper(descriptor.type),
+        listOf(descriptor.resolveDescriptorData())
+    )
+
+    private fun parameter(index: Int, descriptor: ValueParameterDescriptor, parent: DRI) =
+        Parameter(
+            parent.copy(target = index + 1),
+            descriptor.name.asString(),
+            KotlinTypeWrapper(descriptor.type),
+            listOf(descriptor.resolveDescriptorData())
+        )
+
+    private fun MemberScope.functions(parent: DRI): List<Function> =
+        getContributedDescriptors(DescriptorKindFilter.FUNCTIONS) { true }
+            .filterIsInstance<FunctionDescriptor>()
+            .map { visitFunctionDescriptor(it, parent) }
+
+    private fun MemberScope.properties(parent: DRI): List<Property> =
+        getContributedDescriptors(DescriptorKindFilter.VALUES) { true }
+            .filterIsInstance<PropertyDescriptor>()
+            .map { visitPropertyDescriptor(it, parent) }
+
+    private fun MemberScope.classes(parent: DRI): List<Class> =
+        getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) { true }
+            .filterIsInstance<ClassDescriptor>()
+            .map { visitClassDescriptor(it, parent) }
+
+    private fun DeclarationDescriptor.resolveDescriptorData(): PlatformInfo {
+        val doc = findKDoc()
+        val links = doc?.children?.filter { it is KDocLink }?.flatMap { link ->
+            val destination = link.children.first { it is KDocName }.text
+            resolveKDocLink(
+                resolutionFacade.resolveSession.bindingContext,
+                resolutionFacade,
+                this,
+                null,
+                destination.split('.')
+            ).map { Pair(destination, DRI.from(it)) }
+        }?.toMap() ?: emptyMap()
+        return BasePlatformInfo(doc, links, listOf(platformData))
+    }
+
+    private fun ClassDescriptor.resolveClassDescriptionData(): ClassPlatformInfo {
+        return ClassPlatformInfo(resolveDescriptorData(),
+            (getSuperInterfaces() + getAllSuperclassesWithoutAny()).map { DRI.from(it) })
+    }
+
+    private fun getXMLDRIs(descriptor: DeclarationDescriptor, platformInfo: PlatformInfo?) =
+        platformInfo?.docTag?.children
+            ?.filter {
+                it.text.contains("@attr")
+            }?.flatMap { ref ->
+                val matchResult = "@attr\\s+ref\\s+(.+)".toRegex().matchEntire(ref.text)
+                val toFind = matchResult?.groups?.last()?.value.orEmpty()
+                resolveKDocLink(
+                    resolutionFacade.resolveSession.bindingContext,
+                    resolutionFacade,
+                    descriptor,
+                    null,
+                    toFind.split('.')
+                ).map { XMLMega("@attr ref", DRI.from(it)) }
+            }.orEmpty()
+}
+
+data class XMLMega(val key: String, val dri: DRI) : Extra
+
+enum class KotlinClassKindTypes : ClassKind {
+    CLASS,
+    INTERFACE,
+    ENUM_CLASS,
+    ENUM_ENTRY,
+    ANNOTATION_CLASS,
+    OBJECT;
+}
+
+class KotlinTypeWrapper(private val kotlinType: KotlinType) : TypeWrapper {
+    private val declarationDescriptor = kotlinType.constructor.declarationDescriptor
+    private val fqNameSafe = declarationDescriptor?.fqNameSafe
+    override val constructorFqName = fqNameSafe?.asString()
+    override val constructorNamePathSegments: List<String> =
+        fqNameSafe?.pathSegments()?.map { it.asString() } ?: emptyList()
+    override val arguments: List<KotlinTypeWrapper> by lazy { kotlinType.arguments.map {
+        KotlinTypeWrapper(
+            it.type
+        )
+    } }
+    override val dri: DRI? by lazy { declarationDescriptor?.let { DRI.from(it) } }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
new file mode 100644
index 00000000..d08aba21
--- /dev/null
+++ b/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
@@ -0,0 +1,15 @@
+package org.jetbrains.dokka.transformers.descriptors
+
+import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.Model.Package
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+
+interface DescriptorToDocumentationTranslator {
+    fun invoke(
+        packageFragments: Iterable<PackageFragmentDescriptor>,
+        platformData: PlatformData,
+        context: DokkaContext
+    ): Module
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
new file mode 100644
index 00000000..46ba2816
--- /dev/null
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
@@ -0,0 +1,86 @@
+package org.jetbrains.dokka.transformers.documentation
+
+import org.jetbrains.dokka.Model.*
+import org.jetbrains.dokka.Model.Function
+import org.jetbrains.dokka.plugability.DokkaContext
+
+internal object DefaultDocumentationNodeMerger : DocumentationNodeMerger {
+    override fun invoke(modules: Collection<Module>, context: DokkaContext): Module =
+        Module(
+            merge(
+                modules.flatMap { it.packages },
+                Package::mergeWith
+            )
+        )
+}
+
+private fun <T: DocumentationNode> merge(elements: List<T>, reducer: (T, T) -> T): List<T> =
+    elements.groupingBy { it.dri }
+        .reduce { _, left, right -> reducer(left, right)}
+        .values.toList()
+
+fun PlatformInfo.mergeWith(other: PlatformInfo?) = BasePlatformInfo(
+    docTag,
+    links,
+    (platformData + (other?.platformData ?: emptyList())).distinct()
+)
+
+fun ClassPlatformInfo.mergeWith(other: ClassPlatformInfo?) = ClassPlatformInfo(
+    info.mergeWith(other?.info),
+    (inherited + (other?.inherited ?: emptyList())).distinct()
+)
+
+fun List<ClassPlatformInfo>.mergeClassPlatformInfo() : List<ClassPlatformInfo> =
+    groupingBy { it.docTag.toString() + it.links + it.inherited}.reduce {
+            _, left, right -> left.mergeWith(right)
+    }.values.toList()
+
+fun List<PlatformInfo>.merge() : List<PlatformInfo> =
+    groupingBy { it.docTag.toString() + it.links }.reduce {
+        _, left, right -> left.mergeWith(right)
+    }.values.toList()
+
+fun Function.mergeWith(other: Function) = Function(
+    dri,
+    name,
+    returnType,
+    isConstructor,
+    if (receiver != null && other.receiver != null) receiver.mergeWith(other.receiver) else null,
+    merge(parameters + other.parameters, Parameter::mergeWith),
+    expected?.mergeWith(other.expected),
+    (actual + other.actual).merge()
+)
+
+fun Property.mergeWith(other: Property) = Property(
+    dri,
+    name,
+    if (receiver != null && other.receiver != null) receiver.mergeWith(other.receiver) else null,
+    expected?.mergeWith(other.expected),
+    (actual + other.actual).merge()
+)
+
+fun Class.mergeWith(other: Class) = Class(
+    dri,
+    name,
+    kind,
+    merge(constructors + other.constructors, Function::mergeWith),
+    merge(functions + other.functions, Function::mergeWith),
+    merge(properties + other.properties, Property::mergeWith),
+    merge(classes + other.classes, Class::mergeWith),
+    expected?.mergeWith(other.expected),
+    (actual + other.actual).mergeClassPlatformInfo()
+)
+
+fun Parameter.mergeWith(other: Parameter) = Parameter(
+    dri,
+    name,
+    type,
+    (actual + other.actual).merge()
+)
+
+fun Package.mergeWith(other: Package) = Package(
+    dri,
+    merge(functions + other.functions, Function::mergeWith),
+    merge(properties + other.properties, Property::mergeWith),
+    merge(classes + other.classes, Class::mergeWith)
+)
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
new file mode 100644
index 00000000..236d0864
--- /dev/null
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
@@ -0,0 +1,24 @@
+package org.jetbrains.dokka.transformers.documentation
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.pages.DefaultPageBuilder
+import org.jetbrains.dokka.pages.DefaultPageContentBuilder
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.single
+
+
+object DefaultDocumentationToPageTranslator : DocumentationToPageTranslator {
+    override fun invoke(module: Module, context: DokkaContext): ModulePageNode =
+        DefaultPageBuilder { node, kind, operation ->
+            DefaultPageContentBuilder.group(
+                node.dri,
+                node.platformData,
+                kind,
+                context.single(CoreExtensions.markdownToContentConverterFactory).invoke(context),
+                context.logger,
+                operation
+            )
+        }.pageForModule(module)
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
new file mode 100644
index 00000000..0423f47c
--- /dev/null
+++ b/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.dokka.transformers.documentation
+
+import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface DocumentationNodeMerger {
+    operator fun invoke(modules: Collection<Module>, context: DokkaContext): Module
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentationNodeTransformer.kt b/core/src/main/kotlin/transformers/documentation/DocumentationNodeTransformer.kt
new file mode 100644
index 00000000..8ac4a7c2
--- /dev/null
+++ b/core/src/main/kotlin/transformers/documentation/DocumentationNodeTransformer.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.dokka.transformers.documentation
+
+import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface DocumentationNodeTransformer {
+    operator fun invoke(original: Module, context: DokkaContext): Module
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
new file mode 100644
index 00000000..ffe34226
--- /dev/null
+++ b/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
@@ -0,0 +1,12 @@
+package org.jetbrains.dokka.transformers.documentation
+
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.Model.DocumentationNode
+import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface DocumentationToPageTranslator {
+    operator fun invoke(module: Module, context: DokkaContext): ModulePageNode
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt b/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
new file mode 100644
index 00000000..286835f9
--- /dev/null
+++ b/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.dokka.transformers.pages
+
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface PageNodeTransformer {
+    operator fun invoke(input: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode
+}
\ No newline at end of file
diff --git a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
index b7b2d505..0c8bd654 100644
--- a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
+++ b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
@@ -4,9 +4,8 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.DokkaContextConfiguration
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.transformers.PageNodeTransformer
+import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
 class MathjaxPlugin : DokkaPlugin() {
     val transformer by extending {
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index 9de706b2..c177218f 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -4,11 +4,12 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.DokkaConsoleLogger
 import org.jetbrains.dokka.Model.DocumentationNode
 import org.jetbrains.dokka.Model.dfs
-import org.jetbrains.dokka.XMLMega
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.transformers.PageNodeTransformer
+import org.jetbrains.dokka.plugability.single
+import org.jetbrains.dokka.transformers.descriptors.XMLMega
+import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
 class XmlPlugin : DokkaPlugin() {
     val transformer by extending {
@@ -38,9 +39,8 @@ object XmlTransformer : PageNodeTransformer {
                     node.dri,
                     platformData,
                     XMLKind.XmlList,
-                    //Following parameters will soon be drawn from context, so we can leave them like this for the time being
-                    MarkdownToContentConverter(DokkaConsoleLogger),
-                    DokkaConsoleLogger
+                    dokkaContext.single(CoreExtensions.markdownToContentConverterFactory).invoke(dokkaContext),
+                    dokkaContext.logger
                 ) {
                     block("XML Attributes", 2, XMLKind.XmlList, elementsToAdd, platformData) { element ->
                         link(element.dri, XMLKind.XmlList) {
-- 
cgit 


From 970bb62105af3828234eb871230ee9c1cd216af7 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Tue, 26 Nov 2019 20:57:47 +0100
Subject: Making names of extension points more consistent

---
 core/src/main/kotlin/CoreExtensions.kt                |  4 ++--
 core/src/main/kotlin/DokkaGenerator.kt                | 13 ++-----------
 core/src/main/kotlin/plugability/DefaultExtensions.kt |  5 ++---
 3 files changed, 6 insertions(+), 16 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index f56cd854..87509dc4 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -26,8 +26,8 @@ object CoreExtensions {
     val markdownToContentConverterFactory by coreExtension<(DokkaContext) -> MarkdownToContentConverter>()
     val documentationToPageTranslator by coreExtension<DocumentationToPageTranslator>()
     val pageTransformer by coreExtension<PageNodeTransformer>()
-    val renderer by coreExtension<(FileWriter, LocationProvider, DokkaContext) -> Renderer>()
-    val locationProvider by coreExtension<(root: PageNode, DokkaConfiguration, DokkaContext) -> LocationProvider>()
+    val rendererFactory by coreExtension<(FileWriter, LocationProvider, DokkaContext) -> Renderer>()
+    val locationProviderFactory by coreExtension<(root: PageNode, DokkaConfiguration, DokkaContext) -> LocationProvider>()
     val fileExtension by coreExtension<String>()
 
     private fun <T: Any> coreExtension() = object {
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index b6bf7a73..2efcca5a 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,19 +1,10 @@
 package org.jetbrains.dokka
 
 import org.jetbrains.dokka.Model.Module
-import org.jetbrains.dokka.Utilities.pretty
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.DefaultMarkdownToContentConverter
 import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.renderers.FileWriter
-import org.jetbrains.dokka.renderers.HtmlRenderer
-import org.jetbrains.dokka.resolvers.DefaultLocationProvider
-import org.jetbrains.dokka.resolvers.LocationProvider
-import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
-import org.jetbrains.dokka.transformers.descriptors.DokkaDescriptorVisitor
-import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
@@ -57,9 +48,9 @@ class DokkaGenerator(
 
         logger.debug("Rendering")
         val fileWriter = FileWriter(configuration.outputDir, "")
-        val locationProvider = context.single(CoreExtensions.locationProvider)
+        val locationProvider = context.single(CoreExtensions.locationProviderFactory)
             .invoke(transformedPages, configuration, context)
-        val renderer = context.single(CoreExtensions.renderer)
+        val renderer = context.single(CoreExtensions.rendererFactory)
             .invoke(fileWriter, locationProvider, context)
 
         renderer.render(transformedPages)
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index dd656386..d89fc031 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -2,7 +2,6 @@ package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.DefaultMarkdownToContentConverter
-import org.jetbrains.dokka.renderers.DefaultRenderer
 import org.jetbrains.dokka.renderers.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProvider
 import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
@@ -17,8 +16,8 @@ object DefaultExtensions : DokkaExtensionHandler {
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
             CoreExtensions.markdownToContentConverterFactory -> ::DefaultMarkdownToContentConverter
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
-            CoreExtensions.renderer -> ::HtmlRenderer
-            CoreExtensions.locationProvider -> ::DefaultLocationProvider
+            CoreExtensions.rendererFactory -> ::HtmlRenderer
+            CoreExtensions.locationProviderFactory -> ::DefaultLocationProvider
             CoreExtensions.fileExtension -> ".html"
             else -> null
         }.let { listOfNotNull(it) as List<T> }
-- 
cgit 


From d37cf2f32840779706154a3cddbb2239cd80fd84 Mon Sep 17 00:00:00 2001
From: Błażej Kardyś <bkardys@virtuslab.com>
Date: Wed, 27 Nov 2019 17:45:33 +0100
Subject: Cleaning package naming

---
 .../main/kotlin/Analysis/AnalysisEnvironment.kt    | 455 -----------------
 .../main/kotlin/Analysis/CoreKotlinCacheService.kt |  30 --
 .../main/kotlin/Analysis/CoreProjectFileIndex.kt   | 568 ---------------------
 .../main/kotlin/Analysis/DokkaAnalyzerFacades.kt   | 164 ------
 .../main/kotlin/Analysis/JavaResolveExtension.kt   | 131 -----
 core/src/main/kotlin/DokkaBootstrapImpl.kt         |   1 +
 core/src/main/kotlin/DokkaGenerator.kt             |   5 +-
 core/src/main/kotlin/Markdown/MarkdownProcessor.kt |  53 --
 core/src/main/kotlin/Model/DocumentationNode.kt    | 162 ------
 core/src/main/kotlin/Utilities/DokkaLogging.kt     |  31 --
 core/src/main/kotlin/Utilities/Html.kt             |  12 -
 core/src/main/kotlin/Utilities/Path.kt             |   5 -
 core/src/main/kotlin/Utilities/ServiceLocator.kt   |  97 ----
 core/src/main/kotlin/Utilities/Uri.kt              |  40 --
 core/src/main/kotlin/Utilities/nodeDebug.kt        |  51 --
 .../main/kotlin/analysis/AnalysisEnvironment.kt    | 454 ++++++++++++++++
 .../main/kotlin/analysis/CoreKotlinCacheService.kt |  30 ++
 .../main/kotlin/analysis/CoreProjectFileIndex.kt   | 568 +++++++++++++++++++++
 .../main/kotlin/analysis/DokkaAnalyzerFacades.kt   | 164 ++++++
 .../main/kotlin/analysis/JavaResolveExtension.kt   | 131 +++++
 core/src/main/kotlin/markdown/MarkdownProcessor.kt |  53 ++
 core/src/main/kotlin/model/DocumentationNode.kt    | 162 ++++++
 .../pages/DefaultMarkdownToContentConverter.kt     |   2 +-
 .../kotlin/pages/MarkdownToContentConverter.kt     |   3 +-
 core/src/main/kotlin/pages/PageBuilder.kt          |   4 +-
 core/src/main/kotlin/pages/PageContentBuilder.kt   |  12 +-
 core/src/main/kotlin/pages/PageNodes.kt            |   2 +-
 core/src/main/kotlin/plugability/DokkaContext.kt   |   2 +-
 core/src/main/kotlin/renderers/HtmlRenderer.kt     |   4 +-
 .../kotlin/resolvers/DefaultLocationProvider.kt    |   2 +-
 .../DefaultDescriptorToDocumentationTranslator.kt  |   8 +-
 .../DescriptorToDocumentationTranslator.kt         |   3 +-
 .../DefaultDocumentationNodeMerger.kt              |   4 +-
 .../DefaultDocumentationToPageTranslator.kt        |   2 +-
 .../documentation/DocumentationNodeMerger.kt       |   2 +-
 .../documentation/DocumentationNodeTransformer.kt  |   2 +-
 .../documentation/DocumentationToPageTranslator.kt |   5 +-
 core/src/main/kotlin/utilities/DokkaLogging.kt     |  31 ++
 core/src/main/kotlin/utilities/Html.kt             |  12 +
 core/src/main/kotlin/utilities/Path.kt             |   5 +
 core/src/main/kotlin/utilities/ServiceLocator.kt   |  97 ++++
 core/src/main/kotlin/utilities/Uri.kt              |  40 ++
 core/src/main/kotlin/utilities/nodeDebug.kt        |  50 ++
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |   5 +-
 runners/ant/src/main/kotlin/ant/dokka.kt           |   1 +
 runners/cli/src/main/kotlin/cli/main.kt            |   5 +-
 46 files changed, 1833 insertions(+), 1837 deletions(-)
 delete mode 100644 core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
 delete mode 100644 core/src/main/kotlin/Analysis/CoreKotlinCacheService.kt
 delete mode 100644 core/src/main/kotlin/Analysis/CoreProjectFileIndex.kt
 delete mode 100644 core/src/main/kotlin/Analysis/DokkaAnalyzerFacades.kt
 delete mode 100644 core/src/main/kotlin/Analysis/JavaResolveExtension.kt
 delete mode 100644 core/src/main/kotlin/Markdown/MarkdownProcessor.kt
 delete mode 100644 core/src/main/kotlin/Model/DocumentationNode.kt
 delete mode 100644 core/src/main/kotlin/Utilities/DokkaLogging.kt
 delete mode 100644 core/src/main/kotlin/Utilities/Html.kt
 delete mode 100644 core/src/main/kotlin/Utilities/Path.kt
 delete mode 100644 core/src/main/kotlin/Utilities/ServiceLocator.kt
 delete mode 100644 core/src/main/kotlin/Utilities/Uri.kt
 delete mode 100644 core/src/main/kotlin/Utilities/nodeDebug.kt
 create mode 100644 core/src/main/kotlin/analysis/AnalysisEnvironment.kt
 create mode 100644 core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
 create mode 100644 core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
 create mode 100644 core/src/main/kotlin/analysis/DokkaAnalyzerFacades.kt
 create mode 100644 core/src/main/kotlin/analysis/JavaResolveExtension.kt
 create mode 100644 core/src/main/kotlin/markdown/MarkdownProcessor.kt
 create mode 100644 core/src/main/kotlin/model/DocumentationNode.kt
 create mode 100644 core/src/main/kotlin/utilities/DokkaLogging.kt
 create mode 100644 core/src/main/kotlin/utilities/Html.kt
 create mode 100644 core/src/main/kotlin/utilities/Path.kt
 create mode 100644 core/src/main/kotlin/utilities/ServiceLocator.kt
 create mode 100644 core/src/main/kotlin/utilities/Uri.kt
 create mode 100644 core/src/main/kotlin/utilities/nodeDebug.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
deleted file mode 100644
index c816106e..00000000
--- a/core/src/main/kotlin/Analysis/AnalysisEnvironment.kt
+++ /dev/null
@@ -1,455 +0,0 @@
-package org.jetbrains.dokka
-
-import com.google.common.collect.ImmutableMap
-import com.intellij.core.CoreApplicationEnvironment
-import com.intellij.core.CoreModuleManager
-import com.intellij.mock.MockComponentManager
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.extensions.Extensions
-import com.intellij.openapi.module.Module
-import com.intellij.openapi.module.ModuleManager
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.OrderEnumerationHandler
-import com.intellij.openapi.roots.ProjectFileIndex
-import com.intellij.openapi.roots.ProjectRootManager
-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.Analysis.DokkaJsAnalyzerFacade
-import org.jetbrains.dokka.Analysis.DokkaNativeAnalyzerFacade
-import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters
-import org.jetbrains.kotlin.analyzer.common.CommonAnalyzerFacade
-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
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
-import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.cli.jvm.config.*
-import org.jetbrains.kotlin.cli.jvm.index.JavaRoot
-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.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-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.load.java.structure.impl.JavaClassImpl
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.*
-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.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 java.io.File
-
-/**
- * Kotlin as a service entry point
- *
- * Configures environment, analyses files and provides facilities to perform code processing without emitting bytecode
- *
- * $messageCollector: required by compiler infrastructure and will receive all compiler messages
- * $body: optional and can be used to configure environment without creating local variable
- */
-class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPlatform: Platform) : Disposable {
-    val configuration = CompilerConfiguration()
-
-    init {
-        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
-    }
-
-    fun createCoreEnvironment(): KotlinCoreEnvironment {
-        System.setProperty("idea.io.use.fallback", "true")
-
-        val configFiles = when (analysisPlatform) {
-            Platform.jvm, Platform.common -> EnvironmentConfigFiles.JVM_CONFIG_FILES
-            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 moduleManager = object : CoreModuleManager(environment.project, this) {
-            override fun getModules(): Array<out Module> = arrayOf(projectFileIndex.module)
-        }
-
-        CoreApplicationEnvironment.registerComponentInstance(projectComponentManager.picoContainer,
-                ModuleManager::class.java, moduleManager)
-
-        Extensions.registerAreaClass("IDEA_MODULE", null)
-        CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(),
-                OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java)
-
-        projectComponentManager.registerService(ProjectFileIndex::class.java,
-                projectFileIndex)
-        projectComponentManager.registerService(ProjectRootManager::class.java,
-                CoreProjectRootManager(projectFileIndex))
-        return environment
-    }
-
-    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())
-        }
-
-
-    fun createResolutionFacade(environment: KotlinCoreEnvironment): Pair<DokkaResolutionFacade, DokkaResolutionFacade> {
-
-        val projectContext = ProjectContext(environment.project)
-        val sourceFiles = environment.getSourceFiles()
-
-
-        val targetPlatform = when (analysisPlatform) {
-            Platform.js -> JsPlatform
-            Platform.common -> TargetPlatform.Common
-            Platform.native -> KonanPlatform
-            Platform.jvm -> JvmPlatform
-        }
-
-        val library = object : LibraryModuleInfo {
-            override val platform: TargetPlatform
-                get() = targetPlatform
-
-            override fun getLibraryRoots(): Collection<String> {
-                return classpath.map { it.absolutePath }
-            }
-
-            override val name: Name = Name.special("<library>")
-            override fun dependencies(): List<ModuleInfo> = listOf(this)
-        }
-        val module = object : ModuleInfo {
-            override val name: Name = Name.special("<module>")
-            override fun dependencies(): List<ModuleInfo> = listOf(this, library)
-        }
-
-        val sourcesScope = createSourceModuleSearchScope(environment.project, sourceFiles)
-        val modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo> = {
-            when (it) {
-                library -> ModuleContent(it, emptyList(), GlobalSearchScope.notScope(sourcesScope))
-                module -> ModuleContent(it, emptyList(), GlobalSearchScope.allScope(environment.project))
-                else -> throw IllegalArgumentException("Unexpected module info")
-            }
-        }
-
-        var builtIns: JvmBuiltIns? = null
-
-        val resolverForProject = when (analysisPlatform) {
-            Platform.jvm -> {
-                builtIns = JvmBuiltIns(projectContext.storageManager)
-                createJvmResolverForProject(projectContext, module, library, modulesContent, sourcesScope, builtIns)
-            }
-            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 created = DokkaResolutionFacade(environment.project, moduleDescriptor, resolverForModule)
-        val projectComponentManager = environment.project as MockComponentManager
-        projectComponentManager.registerService(KotlinCacheService::class.java, CoreKotlinCacheService(created))
-
-        return created to libraryResolutionFacade
-    }
-
-    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
-        )
-    }
-
-    private fun createJsResolverForProject(
-        projectContext: ProjectContext,
-        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
-        )
-    }
-
-    private fun createNativeResolverForProject(
-        projectContext: ProjectContext,
-        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
-        )
-
-    }
-
-    private fun createJvmResolverForProject(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
-        sourcesScope: GlobalSearchScope,
-        builtIns: KotlinBuiltIns
-    ): ResolverForProjectImpl<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)
-                }
-
-                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)
-                    else -> throw IllegalArgumentException("Unexpected module info")
-                }
-            },
-            modulePlatforms = { JvmPlatform.multiTargetPlatform },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { JvmAnalyzerFacade },
-            platformParameters = {
-                JvmPlatformParameters ({ content ->
-                    JvmPackagePartProvider(
-                        configuration.languageVersionSettings,
-                        content.moduleContentScope)
-                        .apply {
-                            addRoots(javaRoots, messageCollector)
-                        }
-                }, {
-                    val file = (it as JavaClassImpl).psi.containingFile.virtualFile
-                    if (file in sourcesScope)
-                        module
-                    else
-                        library
-                })
-            },
-            targetEnvironment = CompilerEnvironment,
-            builtIns = builtIns
-        )
-    }
-
-    fun loadLanguageVersionSettings(languageVersionString: String?, apiVersionString: String?) {
-        val languageVersion = LanguageVersion.fromVersionString(languageVersionString) ?: LanguageVersion.LATEST_STABLE
-        val apiVersion = apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
-        configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
-    }
-
-    /**
-     * Classpath for this environment.
-     */
-    val classpath: List<File>
-        get() = configuration.jvmClasspathRoots
-
-    /**
-     * Adds list of paths to classpath.
-     * $paths: collection of files to add
-     */
-    fun addClasspath(paths: List<File>) {
-        if (analysisPlatform == Platform.js) {
-            configuration.addAll(JSConfigurationKeys.LIBRARIES, paths.map { it.absolutePath })
-        }
-        configuration.addJvmClasspathRoots(paths)
-    }
-
-    /**
-     * Adds path to classpath.
-     * $path: path to add
-     */
-    fun addClasspath(path: File) {
-        if (analysisPlatform == Platform.js) {
-            configuration.add(JSConfigurationKeys.LIBRARIES, path.absolutePath)
-        }
-        configuration.addJvmClasspathRoot(path)
-    }
-
-    /**
-     * List of source roots for this environment.
-     */
-    val sources: List<String>
-        get() = configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
-                ?.filterIsInstance<KotlinSourceRoot>()
-                ?.map { it.path } ?: emptyList()
-
-    /**
-     * Adds list of paths to source roots.
-     * $list: collection of files to add
-     */
-    fun addSources(list: List<String>) {
-        list.forEach {
-            configuration.addKotlinSourceRoot(it)
-            val file = File(it)
-            if (file.isDirectory || file.extension == ".java") {
-                configuration.addJavaSourceRoot(file)
-            }
-        }
-    }
-
-    fun addRoots(list: List<ContentRoot>) {
-        configuration.addAll(CLIConfigurationKeys.CONTENT_ROOTS, list)
-    }
-
-    /**
-     * Disposes the environment and frees all associated resources.
-     */
-    override fun dispose() {
-        Disposer.dispose(this)
-    }
-}
-
-fun contentRootFromPath(path: String): ContentRoot {
-    val file = File(path)
-    return if (file.extension == "java") JavaSourceRoot(file, null) else KotlinSourceRoot(path, false)
-}
-
-
-class DokkaResolutionFacade(override val project: Project,
-                            override val moduleDescriptor: ModuleDescriptor,
-                            val resolverForModule: ResolverForModule) : ResolutionFacade {
-    override fun analyzeWithAllCompilerChecks(elements: Collection<KtElement>): AnalysisResult {
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> tryGetFrontendService(element: PsiElement, serviceClass: Class<T>): T? {
-        return resolverForModule.componentProvider.tryGetService(serviceClass)
-    }
-
-    override fun resolveToDescriptor(declaration: KtDeclaration, bodyResolveMode: BodyResolveMode): DeclarationDescriptor {
-        return resolveSession.resolveToDescriptor(declaration)
-    }
-
-    override fun analyze(elements: Collection<KtElement>, bodyResolveMode: BodyResolveMode): BindingContext {
-        throw UnsupportedOperationException()
-    }
-
-    val resolveSession: ResolveSession get() = getFrontendService(ResolveSession::class.java)
-
-    override fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
-        if (element is KtDeclaration) {
-            val descriptor = resolveToDescriptor(element)
-            return object : BindingContext {
-                override fun <K : Any?, V : Any?> getKeys(p0: WritableSlice<K, V>?): Collection<K> {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun getType(p0: KtExpression): KotlinType? {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun <K : Any?, V : Any?> get(slice: ReadOnlySlice<K, V>?, key: K): V? {
-                    if (key != element) {
-                        throw UnsupportedOperationException()
-                    }
-                    return when {
-                        slice == BindingContext.DECLARATION_TO_DESCRIPTOR -> descriptor as V
-                        slice == BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER && (element as KtParameter).hasValOrVar() -> descriptor as V
-                        else -> null
-                    }
-                }
-
-                override fun getDiagnostics(): Diagnostics {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun addOwnDataTo(p0: BindingTrace, p1: Boolean) {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun <K : Any?, V : Any?> getSliceContents(p0: ReadOnlySlice<K, V>): ImmutableMap<K, V> {
-                    throw UnsupportedOperationException()
-                }
-
-            }
-        }
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> getFrontendService(element: PsiElement, serviceClass: Class<T>): T {
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> getFrontendService(serviceClass: Class<T>): T {
-        return resolverForModule.componentProvider.getService(serviceClass)
-    }
-
-    override fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
-        return resolverForModule.componentProvider.getService(serviceClass)
-    }
-
-    override fun <T : Any> getIdeService(serviceClass: Class<T>): T {
-        throw UnsupportedOperationException()
-    }
-
-}
diff --git a/core/src/main/kotlin/Analysis/CoreKotlinCacheService.kt b/core/src/main/kotlin/Analysis/CoreKotlinCacheService.kt
deleted file mode 100644
index 31b8ffc7..00000000
--- a/core/src/main/kotlin/Analysis/CoreKotlinCacheService.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.jetbrains.dokka
-
-import com.intellij.psi.PsiFile
-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
-
-
-class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade) : KotlinCacheService {
-    override fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
-        return resolutionFacade
-    }
-
-    override fun getResolutionFacadeByFile(file: PsiFile, platform: TargetPlatform): ResolutionFacade {
-        return resolutionFacade
-    }
-
-    override fun getResolutionFacadeByModuleInfo(moduleInfo: ModuleInfo, platform: TargetPlatform): ResolutionFacade? {
-        return resolutionFacade
-    }
-
-    override fun getSuppressionCache(): KotlinSuppressCache {
-        throw UnsupportedOperationException()
-    }
-
-}
-
diff --git a/core/src/main/kotlin/Analysis/CoreProjectFileIndex.kt b/core/src/main/kotlin/Analysis/CoreProjectFileIndex.kt
deleted file mode 100644
index f5fbf991..00000000
--- a/core/src/main/kotlin/Analysis/CoreProjectFileIndex.kt
+++ /dev/null
@@ -1,568 +0,0 @@
-package org.jetbrains.dokka
-
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.components.BaseComponent
-import com.intellij.openapi.extensions.ExtensionPointName
-import com.intellij.openapi.module.Module
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.projectRoots.Sdk
-import com.intellij.openapi.projectRoots.SdkAdditionalData
-import com.intellij.openapi.projectRoots.SdkModificator
-import com.intellij.openapi.projectRoots.SdkTypeId
-import com.intellij.openapi.roots.*
-import com.intellij.openapi.roots.impl.ProjectOrderEnumerator
-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.VirtualFile
-import com.intellij.openapi.vfs.VirtualFileFilter
-import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.util.messages.MessageBus
-import org.jetbrains.jps.model.module.JpsModuleSourceRootType
-import org.jetbrains.kotlin.cli.common.config.ContentRoot
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
-import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
-import org.picocontainer.PicoContainer
-import java.io.File
-
-/**
- * Workaround for the lack of ability to create a ProjectFileIndex implementation using only
- * classes from projectModel-{api,impl}.
- */
-class CoreProjectFileIndex(private val project: Project, contentRoots: List<ContentRoot>) : ProjectFileIndex, ModuleFileIndex {
-    override fun iterateContent(p0: ContentIterator, p1: VirtualFileFilter?): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator, p2: VirtualFileFilter?): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInLibrary(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    val sourceRoots = contentRoots.filter { it !is JvmClasspathRoot }
-    val classpathRoots = contentRoots.filterIsInstance<JvmClasspathRoot>()
-
-    val module: Module = object : UserDataHolderBase(), Module {
-        override fun isDisposed(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOptionValue(p0: String): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun clearOption(p0: String) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getName(): String = "<Dokka module>"
-
-        override fun getModuleWithLibrariesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependentsScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleContentScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isLoaded(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun setOption(p0: String, p1: String?) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependenciesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependenciesAndLibrariesScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getProject(): Project = this@CoreProjectFileIndex.project
-
-        override fun getModuleContentWithDependenciesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleFilePath(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleTestsWithDependentsScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleRuntimeScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleFile(): VirtualFile? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getExtensions(p0: ExtensionPointName<T>): Array<out T> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getComponent(p0: String): BaseComponent? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponent(p0: Class<T>, p1: T): T {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponent(interfaceClass: Class<T>): T? {
-            if (interfaceClass == ModuleRootManager::class.java) {
-                return moduleRootManager as T
-            }
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDisposed(): Condition<*> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponents(p0: Class<T>): Array<out T> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getPicoContainer(): PicoContainer {
-            throw UnsupportedOperationException()
-        }
-
-        override fun hasComponent(p0: Class<*>): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getMessageBus(): MessageBus {
-            throw UnsupportedOperationException()
-        }
-
-        override fun dispose() {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val sdk: Sdk = object : Sdk, RootProvider {
-        override fun getFiles(rootType: OrderRootType): Array<out VirtualFile> = classpathRoots
-                .mapNotNull { StandardFileSystems.local().findFileByPath(it.file.path) }
-                .toTypedArray()
-
-        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener, p1: Disposable) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun removeRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkModificator(): SdkModificator {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getName(): String = "<dokka SDK>"
-
-        override fun getRootProvider(): RootProvider = this
-
-        override fun getHomePath(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getVersionString(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkAdditionalData(): SdkAdditionalData? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun clone(): Any {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkType(): SdkTypeId {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getHomeDirectory(): VirtualFile? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getUserData(p0: Key<T>): T? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> putUserData(p0: Key<T>, p1: T?) {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val moduleSourceOrderEntry = object : ModuleSourceOrderEntry {
-        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
-            throw UnsupportedOperationException()
-        }
-
-
-        override fun getPresentableName(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOwnerModule(): Module = module
-
-
-        override fun isValid(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun compareTo(other: OrderEntry?): Int {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootModel(): ModuleRootModel = moduleRootManager
-
-        override fun isSynthetic(): Boolean {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val sdkOrderEntry = object : JdkOrderEntry {
-        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getJdkName(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getJdk(): Sdk = sdk
-
-        override fun getPresentableName(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOwnerModule(): Module {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isValid(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootFiles(p0: OrderRootType): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootUrls(p0: OrderRootType): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun compareTo(other: OrderEntry?): Int {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isSynthetic(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-    }
-
-    inner class MyModuleRootManager : ModuleRootManager() {
-        override fun getExternalSource(): ProjectModelExternalSource? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getExcludeRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentEntries(): Array<out ContentEntry> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getExcludeRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> processOrder(p0: RootPolicy<R>?, p1: R): R {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: Boolean): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: JpsModuleSourceRootType<*>): MutableList<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun orderEntries(): OrderEnumerator =
-                ProjectOrderEnumerator(project, null).using(object : RootModelProvider {
-                    override fun getModules(): Array<out Module> = arrayOf(module)
-
-                    override fun getRootModel(p0: Module): ModuleRootModel = this@MyModuleRootManager
-                })
-
-        override fun <T : Any?> getModuleExtension(p0: Class<T>): T {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDependencyModuleNames(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModule(): Module = this@CoreProjectFileIndex.module
-
-        override fun isSdkInherited(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOrderEntries(): Array<out OrderEntry> = arrayOf(moduleSourceOrderEntry, sdkOrderEntry)
-
-        override fun getSourceRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRootUrls(p0: Boolean): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdk(): Sdk? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleDependencies(): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleDependencies(p0: Boolean): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModifiableModel(): ModifiableRootModel {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isDependsOn(p0: Module?): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getFileIndex(): ModuleFileIndex {
-            return this@CoreProjectFileIndex
-        }
-
-        override fun getDependencies(): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDependencies(p0: Boolean): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    val moduleRootManager = MyModuleRootManager()
-
-    override fun getContentRootForFile(p0: VirtualFile): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootForFile(p0: VirtualFile, p1: Boolean): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getPackageNameByDirectory(p0: VirtualFile): String? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInLibrarySource(file: VirtualFile): Boolean = false
-
-    override fun getClassRootForFile(file: VirtualFile): VirtualFile? =
-        classpathRoots.firstOrNull { it.contains(file) }?.let { StandardFileSystems.local().findFileByPath(it.file.path) }
-
-    override fun getOrderEntriesForFile(file: VirtualFile): List<OrderEntry> =
-        if (classpathRoots.contains(file)) listOf(sdkOrderEntry) else emptyList()
-
-    override fun isInLibraryClasses(file: VirtualFile): Boolean = classpathRoots.contains(file)
-
-    override fun isExcluded(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getSourceRootForFile(p0: VirtualFile): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isUnderIgnored(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isLibraryClassFile(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getModuleForFile(file: VirtualFile): Module? =
-            if (sourceRoots.contains(file)) module else null
-
-    private fun List<ContentRoot>.contains(file: VirtualFile): Boolean = any { it.contains(file) }
-
-    override fun getModuleForFile(p0: VirtualFile, p1: Boolean): Module? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInSource(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isIgnored(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isContentSourceFile(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInSourceContent(file: VirtualFile): Boolean = sourceRoots.contains(file)
-
-    override fun iterateContent(p0: ContentIterator): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInContent(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInTestSourceContent(file: VirtualFile): Boolean = false
-
-    override fun isUnderSourceRootOfType(p0: VirtualFile, p1: MutableSet<out JpsModuleSourceRootType<*>>): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getOrderEntryForFile(p0: VirtualFile): OrderEntry? {
-        throw UnsupportedOperationException()
-    }
-}
-
-class CoreProjectRootManager(val projectFileIndex: CoreProjectFileIndex) : ProjectRootManager() {
-    override fun orderEntries(): OrderEnumerator {
-        throw UnsupportedOperationException()
-    }
-
-    override fun orderEntries(p0: MutableCollection<out Module>): OrderEnumerator {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootsFromAllModules(): Array<out VirtualFile>? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun setProjectSdk(p0: Sdk?) {
-        throw UnsupportedOperationException()
-    }
-
-    override fun setProjectSdkName(p0: String?) {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getModuleSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentSourceRoots(): Array<out VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getFileIndex(): ProjectFileIndex = projectFileIndex
-
-    override fun getProjectSdkName(): String? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getProjectSdk(): Sdk? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRoots(): Array<out VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootUrls(): MutableList<String> {
-        throw UnsupportedOperationException()
-    }
-
-}
-
-fun ContentRoot.contains(file: VirtualFile) = when (this) {
-    is JvmContentRoot -> {
-        val path = if (file.fileSystem.protocol == StandardFileSystems.JAR_PROTOCOL)
-            StandardFileSystems.getVirtualFileForJar(file)?.path ?: file.path
-        else
-            file.path
-        File(path).startsWith(this.file.absoluteFile)
-    }
-    is KotlinSourceRoot -> File(file.path).startsWith(File(this.path).absoluteFile)
-    else -> false
-}
diff --git a/core/src/main/kotlin/Analysis/DokkaAnalyzerFacades.kt b/core/src/main/kotlin/Analysis/DokkaAnalyzerFacades.kt
deleted file mode 100644
index 874341dd..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
deleted file mode 100644
index 4dc6b366..00000000
--- a/core/src/main/kotlin/Analysis/JavaResolveExtension.kt
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-@file:JvmName("JavaResolutionUtils")
-
-package org.jetbrains.dokka
-
-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.*
-import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-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.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
-
-// TODO: Remove that file
-
-@JvmOverloads
-fun PsiMethod.getJavaMethodDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    val method = originalElement as? PsiMethod ?: return null
-    if (method.containingClass == null || !Name.isValidIdentifier(method.name)) return null
-    val resolver = method.getJavaDescriptorResolver(resolutionFacade)
-    return when {
-        method.isConstructor -> resolver?.resolveConstructor(JavaConstructorImpl(method))
-        else -> resolver?.resolveMethod(JavaMethodImpl(method))
-    }
-}
-
-@JvmOverloads
-fun PsiClass.getJavaClassDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): ClassDescriptor? {
-    val psiClass = originalElement as? PsiClass ?: return null
-    return psiClass.getJavaDescriptorResolver(resolutionFacade)?.resolveClass(JavaClassImpl(psiClass))
-}
-
-@JvmOverloads
-fun PsiField.getJavaFieldDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): PropertyDescriptor? {
-    val field = originalElement as? PsiField ?: return null
-    return field.getJavaDescriptorResolver(resolutionFacade)?.resolveField(JavaFieldImpl(field))
-}
-
-@JvmOverloads
-fun PsiMember.getJavaMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    return when (this) {
-        is PsiEnumConstant -> containingClass?.getJavaClassDescriptor(resolutionFacade)
-        is PsiClass -> getJavaClassDescriptor(resolutionFacade)
-        is PsiMethod -> getJavaMethodDescriptor(resolutionFacade)
-        is PsiField -> getJavaFieldDescriptor(resolutionFacade)
-        else -> null
-    }
-}
-
-@JvmOverloads
-fun PsiMember.getJavaOrKotlinMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    val callable = unwrapped
-    return when (callable) {
-        is PsiMember -> getJavaMemberDescriptor(resolutionFacade)
-        is KtDeclaration -> {
-            val descriptor = resolutionFacade.resolveToDescriptor(callable)
-            if (descriptor is ClassDescriptor && this is PsiMethod) descriptor.unsubstitutedPrimaryConstructor else descriptor
-        }
-        else -> null
-    }
-}
-
-private fun PsiElement.getJavaDescriptorResolver(resolutionFacade: ResolutionFacade): JavaDescriptorResolver? {
-    return resolutionFacade.tryGetFrontendService(this, JavaDescriptorResolver::class.java)
-}
-
-private fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): DeclarationDescriptor? {
-    return getContainingScope(method)
-            ?.getContributedDescriptors(nameFilter = { true }, kindFilter = DescriptorKindFilter.CALLABLES)
-            ?.filterIsInstance<DeclarationDescriptorWithSource>()
-            ?.findByJavaElement(method)
-}
-
-private fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructor): ConstructorDescriptor? {
-    return resolveClass(constructor.containingClass)?.constructors?.findByJavaElement(constructor)
-}
-
-private fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescriptor? {
-    return getContainingScope(field)?.getContributedVariables(field.name, NoLookupLocation.FROM_IDE)?.findByJavaElement(field)
-}
-
-private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): MemberScope? {
-    val containingClass = resolveClass(member.containingClass)
-    return if (member.isStatic)
-        containingClass?.staticScope
-    else
-        containingClass?.defaultType?.memberScope
-}
-
-private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {
-    return firstOrNull { member ->
-        val memberJavaElement = (member.original.source as? JavaSourceElement)?.javaElement
-        when {
-            memberJavaElement == javaElement ->
-                true
-            memberJavaElement is JavaElementImpl<*> && javaElement is JavaElementImpl<*> ->
-                memberJavaElement.psi.isEquivalentTo(javaElement.psi)
-            else ->
-                false
-        }
-    }
-}
-
-fun PsiElement.javaResolutionFacade() =
-    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatform)!!
diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index 2e52d9c6..d11f1623 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -2,6 +2,7 @@ package org.jetbrains.dokka
 
 import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaConfiguration.PackageOptions
+import org.jetbrains.dokka.utilities.DokkaLogger
 
 import java.util.function.BiConsumer
 
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 2efcca5a..8661ec45 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,10 +1,13 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.analysis.AnalysisEnvironment
+import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.renderers.FileWriter
+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
diff --git a/core/src/main/kotlin/Markdown/MarkdownProcessor.kt b/core/src/main/kotlin/Markdown/MarkdownProcessor.kt
deleted file mode 100644
index 2c8f7a73..00000000
--- a/core/src/main/kotlin/Markdown/MarkdownProcessor.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-package org.jetbrains.dokka
-
-import org.intellij.markdown.IElementType
-import org.intellij.markdown.MarkdownElementTypes
-import org.intellij.markdown.ast.ASTNode
-import org.intellij.markdown.ast.LeafASTNode
-import org.intellij.markdown.ast.getTextInNode
-import org.intellij.markdown.flavours.commonmark.CommonMarkFlavourDescriptor
-import org.intellij.markdown.parser.MarkdownParser
-
-class MarkdownNode(val node: ASTNode, val parent: MarkdownNode?, val markdown: String) {
-    val children: List<MarkdownNode> = node.children.map { MarkdownNode(it, this, markdown) }
-    val type: IElementType get() = node.type
-    val text: String get() = node.getTextInNode(markdown).toString()
-    fun child(type: IElementType): MarkdownNode? = children.firstOrNull { it.type == type }
-
-    val previous get() = parent?.children?.getOrNull(parent.children.indexOf(this) - 1)
-
-    override fun toString(): String = StringBuilder().apply { presentTo(this) }.toString()
-}
-
-fun MarkdownNode.visit(action: (MarkdownNode, () -> Unit) -> Unit) {
-    action(this) {
-        for (child in children) {
-            child.visit(action)
-        }
-    }
-}
-
-fun MarkdownNode.toTestString(): String {
-    val sb = StringBuilder()
-    var level = 0
-    visit { node, visitChildren ->
-        sb.append(" ".repeat(level * 2))
-        node.presentTo(sb)
-        sb.appendln()
-        level++
-        visitChildren()
-        level--
-    }
-    return sb.toString()
-}
-
-private fun MarkdownNode.presentTo(sb: StringBuilder) {
-    sb.append(type.toString())
-    sb.append(":" + text.replace("\n", "\u23CE"))
-}
-
-fun parseMarkdown(markdown: String): MarkdownNode {
-    if (markdown.isEmpty())
-        return MarkdownNode(LeafASTNode(MarkdownElementTypes.MARKDOWN_FILE, 0, 0), null, markdown)
-    return MarkdownNode(MarkdownParser(CommonMarkFlavourDescriptor()).buildMarkdownTreeFromString(markdown), null, markdown)
-}
diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
deleted file mode 100644
index b1d4be55..00000000
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ /dev/null
@@ -1,162 +0,0 @@
-package org.jetbrains.dokka.Model
-
-import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
-
-class Module(val packages: List<Package>) : DocumentationNode() {
-    override val dri: DRI = DRI.topLevel
-    override val children: List<Package> = packages
-    override val extra: MutableSet<Extra> = mutableSetOf()
-}
-
-class Package(
-    override val dri: DRI,
-    override val functions: List<Function>,
-    override val properties: List<Property>,
-    override val classes: List<Class>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : ScopeNode() {
-    override val name = dri.packageName.orEmpty()
-}
-
-class Class(
-    override val dri: DRI,
-    override val name: String,
-    val kind: ClassKind,
-    val constructors: List<Function>,
-    override val functions: List<Function>,
-    override val properties: List<Property>,
-    override val classes: List<Class>,
-    override val expected: ClassPlatformInfo?,
-    override val actual: List<ClassPlatformInfo>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : ScopeNode() {
-    val inherited by lazy { platformInfo.mapNotNull { (it as? ClassPlatformInfo)?.inherited }.flatten() }
-}
-
-class Function(
-    override val dri: DRI,
-    override val name: String,
-    val returnType: TypeWrapper?,
-    val isConstructor: Boolean,
-    override val receiver: Parameter?,
-    val parameters: List<Parameter>,
-    override val expected: PlatformInfo?,
-    override val actual: List<PlatformInfo>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : CallableNode() {
-    override val children: List<Parameter>
-        get() = listOfNotNull(receiver) + parameters
-}
-
-class Property(
-    override val dri: DRI,
-    override val name: String,
-    override val receiver: Parameter?,
-    override val expected: PlatformInfo?,
-    override val actual: List<PlatformInfo>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : CallableNode() {
-    override val children: List<Parameter>
-        get() = listOfNotNull(receiver)
-}
-
-// TODO: treat named Parameters and receivers differently
-class Parameter(
-    override val dri: DRI,
-    override val name: String?,
-    val type: TypeWrapper,
-    override val actual: List<PlatformInfo>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : DocumentationNode() {
-    override val children: List<DocumentationNode>
-        get() = emptyList()
-}
-
-interface PlatformInfo {
-    val docTag: KDocTag?
-    val links: Map<String, DRI>
-    val platformData: List<PlatformData>
-}
-
-class BasePlatformInfo(
-    override val docTag: KDocTag?,
-    override val links: Map<String, DRI>,
-    override val platformData: List<PlatformData>) : PlatformInfo {
-
-    override fun equals(other: Any?): Boolean =
-        other is PlatformInfo && (
-                docTag?.text == other.docTag?.text &&
-                        links == other.links)
-
-    override fun hashCode(): Int =
-        listOf(docTag?.text, links).hashCode()
-}
-
-class ClassPlatformInfo(
-    val info: PlatformInfo,
-    val inherited: List<DRI>) : PlatformInfo by info
-
-abstract class DocumentationNode {
-    open val expected: PlatformInfo? = null
-    open val actual: List<PlatformInfo> = emptyList()
-    open val name: String? = null
-    val platformInfo by lazy { listOfNotNull(expected) + actual }
-    val platformData by lazy { platformInfo.flatMap { it.platformData }.toSet() }
-
-    abstract val dri: DRI
-
-    abstract val children: List<DocumentationNode>
-
-    override fun toString(): String {
-        return "${javaClass.simpleName}($dri)" + briefDocstring.takeIf { it.isNotBlank() }?.let { " [$it]" }.orEmpty()
-    }
-
-    override fun equals(other: Any?) = other is DocumentationNode && this.dri == other.dri
-
-    override fun hashCode() = dri.hashCode()
-
-    val commentsData: List<Pair<String, Map<String, DRI>>>
-        get() = platformInfo.mapNotNull { it.docTag?.let { tag -> Pair(tag.getContent(), it.links) } }
-
-    val briefDocstring: String
-        get() = platformInfo.firstOrNull()?.docTag?.getContent().orEmpty().shorten(40)
-
-    open val extra: MutableSet<Extra> = mutableSetOf()
-}
-
-abstract class ScopeNode : DocumentationNode() {
-    abstract val functions: List<Function>
-    abstract val properties: List<Property>
-    abstract val classes: List<Class>
-
-    override val children: List<DocumentationNode>
-        get() = functions + properties + classes
-}
-
-abstract class CallableNode : DocumentationNode() {
-    abstract val receiver: Parameter?
-}
-
-private fun String.shorten(maxLength: Int) = lineSequence().first().let {
-    if (it.length != length || it.length > maxLength) it.take(maxLength - 3) + "..." else it
-}
-
-interface TypeWrapper {
-    val constructorFqName: String?
-    val constructorNamePathSegments: List<String>
-    val arguments: List<KotlinTypeWrapper>
-    val dri: DRI?
-}
-interface ClassKind
-
-fun DocumentationNode.dfs(predicate: (DocumentationNode) -> Boolean): DocumentationNode? =
-    if (predicate(this)) {
-        this
-    } else {
-        this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull()
-    }
-
-interface Extra
\ No newline at end of file
diff --git a/core/src/main/kotlin/Utilities/DokkaLogging.kt b/core/src/main/kotlin/Utilities/DokkaLogging.kt
deleted file mode 100644
index d0d1bff6..00000000
--- a/core/src/main/kotlin/Utilities/DokkaLogging.kt
+++ /dev/null
@@ -1,31 +0,0 @@
-package org.jetbrains.dokka
-
-interface DokkaLogger {
-    fun debug(message: String)
-    fun info(message: String)
-    fun progress(message: String)
-    fun warn(message: String)
-    fun error(message: String)
-}
-
-object DokkaConsoleLogger : DokkaLogger {
-    var warningCount: Int = 0
-
-    override fun debug(message: String)= println(message)
-
-    override fun progress(message: String) = println("PROGRESS: $message")
-
-    override fun info(message: String) = println(message)
-
-    override fun warn(message: String) = println("WARN: $message").also { warningCount++ }
-
-    override fun error(message: String) = println("ERROR: $message")
-
-    fun report() {
-        if (warningCount > 0) {
-            println("generation completed with $warningCount warnings")
-        } else {
-            println("generation completed successfully")
-        }
-    }
-}
diff --git a/core/src/main/kotlin/Utilities/Html.kt b/core/src/main/kotlin/Utilities/Html.kt
deleted file mode 100644
index de1ce1a5..00000000
--- a/core/src/main/kotlin/Utilities/Html.kt
+++ /dev/null
@@ -1,12 +0,0 @@
-package org.jetbrains.dokka
-
-import java.net.URLEncoder
-
-
-/**
- * Replaces symbols reserved in HTML with their respective entities.
- * Replaces & with &amp;, < with &lt; and > with &gt;
- */
-fun String.htmlEscape(): String = replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
-
-fun String.urlEncoded(): String = URLEncoder.encode(this, "UTF-8")
\ No newline at end of file
diff --git a/core/src/main/kotlin/Utilities/Path.kt b/core/src/main/kotlin/Utilities/Path.kt
deleted file mode 100644
index 05838499..00000000
--- a/core/src/main/kotlin/Utilities/Path.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package org.jetbrains.dokka
-
-import java.io.File
-
-fun File.appendExtension(extension: String) = if (extension.isEmpty()) this else File(path + "." + extension)
diff --git a/core/src/main/kotlin/Utilities/ServiceLocator.kt b/core/src/main/kotlin/Utilities/ServiceLocator.kt
deleted file mode 100644
index eda83422..00000000
--- a/core/src/main/kotlin/Utilities/ServiceLocator.kt
+++ /dev/null
@@ -1,97 +0,0 @@
-package org.jetbrains.dokka.Utilities
-
-import java.io.File
-import java.net.URISyntaxException
-import java.net.URL
-import java.util.*
-import java.util.jar.JarFile
-import java.util.zip.ZipEntry
-
-data class ServiceDescriptor(val name: String, val category: String, val description: String?, val className: String)
-
-class ServiceLookupException(message: String) : Exception(message)
-
-object ServiceLocator {
-    fun <T : Any> lookup(clazz: Class<T>, category: String, implementationName: String): T {
-        val descriptor = lookupDescriptor(category, implementationName)
-        return lookup(clazz, descriptor)
-    }
-
-    fun <T : Any> lookup(
-        clazz: Class<T>,
-        descriptor: ServiceDescriptor
-    ): T {
-        val loadedClass = javaClass.classLoader.loadClass(descriptor.className)
-        val constructor = loadedClass.constructors.firstOrNull { it.parameterTypes.isEmpty() } ?: throw ServiceLookupException("Class ${descriptor.className} has no corresponding constructor")
-
-        val implementationRawType: Any =
-            if (constructor.parameterTypes.isEmpty()) constructor.newInstance() else constructor.newInstance(constructor)
-
-        if (!clazz.isInstance(implementationRawType)) {
-            throw ServiceLookupException("Class ${descriptor.className} is not a subtype of ${clazz.name}")
-        }
-
-        @Suppress("UNCHECKED_CAST")
-        return implementationRawType as T
-    }
-
-    private fun lookupDescriptor(category: String, implementationName: String): ServiceDescriptor {
-        val properties = javaClass.classLoader.getResourceAsStream("dokka/$category/$implementationName.properties")?.use { stream ->
-            Properties().let { properties ->
-                properties.load(stream)
-                properties
-            }
-        } ?: throw ServiceLookupException("No implementation with name $implementationName found in category $category")
-
-        val className = properties["class"]?.toString() ?: throw ServiceLookupException("Implementation $implementationName has no class configured")
-
-        return ServiceDescriptor(implementationName, category, properties["description"]?.toString(), className)
-    }
-
-    fun URL.toFile(): File {
-        assert(protocol == "file")
-
-        return try {
-            File(toURI())
-        } catch (e: URISyntaxException) { //Try to handle broken URLs, with unescaped spaces
-            File(path)
-        }
-    }
-
-    fun allServices(category: String): List<ServiceDescriptor> {
-        val entries = this.javaClass.classLoader.getResources("dokka/$category")?.toList() ?: emptyList()
-
-        return entries.flatMap {
-            when (it.protocol) {
-                "file" -> it.toFile().listFiles()?.filter { it.extension == "properties" }?.map { lookupDescriptor(category, it.nameWithoutExtension) } ?: emptyList()
-                "jar" -> {
-                    val file = JarFile(URL(it.file.substringBefore("!")).toFile())
-                    try {
-                        val jarPath = it.file.substringAfterLast("!").removePrefix("/").removeSuffix("/")
-                        file.entries()
-                                .asSequence()
-                                .filter { entry -> !entry.isDirectory && entry.path == jarPath && entry.extension == "properties" }
-                                .map { entry ->
-                                    lookupDescriptor(category, entry.fileName.substringBeforeLast("."))
-                                }.toList()
-                    } finally {
-                        file.close()
-                    }
-                }
-                else -> emptyList<ServiceDescriptor>()
-            }
-        }
-    }
-}
-
-inline fun <reified T : Any> ServiceLocator.lookup(category: String, implementationName: String): T = lookup(T::class.java, category, implementationName)
-inline fun <reified T : Any> ServiceLocator.lookup(desc: ServiceDescriptor): T = lookup(T::class.java, desc)
-
-private val ZipEntry.fileName: String
-    get() = name.substringAfterLast("/", name)
-
-private val ZipEntry.path: String
-    get() = name.substringBeforeLast("/", "").removePrefix("/")
-
-private val ZipEntry.extension: String?
-    get() = fileName.let { fn -> if ("." in fn) fn.substringAfterLast(".") else null }
diff --git a/core/src/main/kotlin/Utilities/Uri.kt b/core/src/main/kotlin/Utilities/Uri.kt
deleted file mode 100644
index 9827c624..00000000
--- a/core/src/main/kotlin/Utilities/Uri.kt
+++ /dev/null
@@ -1,40 +0,0 @@
-package org.jetbrains.dokka
-
-import java.net.URI
-
-
-fun URI.relativeTo(uri: URI): URI {
-    // Normalize paths to remove . and .. segments
-    val base = uri.normalize()
-    val child = this.normalize()
-
-    fun StringBuilder.appendRelativePath() {
-        // Split paths into segments
-        var bParts = base.path.split('/').dropLastWhile { it.isEmpty() }
-        val cParts = child.path.split('/').dropLastWhile { it.isEmpty() }
-
-        // Discard trailing segment of base path
-        if (bParts.isNotEmpty() && !base.path.endsWith("/")) {
-            bParts = bParts.dropLast(1)
-        }
-
-        // Compute common prefix
-        val commonPartsSize = bParts.zip(cParts).takeWhile { (basePart, childPart) -> basePart == childPart }.count()
-        bParts.drop(commonPartsSize).joinTo(this, separator = "") { "../" }
-        cParts.drop(commonPartsSize).joinTo(this, separator = "/")
-    }
-
-    return URI.create(buildString {
-        if (base.path != child.path) {
-            appendRelativePath()
-        }
-        child.rawQuery?.let {
-            append("?")
-            append(it)
-        }
-        child.rawFragment?.let {
-            append("#")
-            append(it)
-        }
-    })
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/Utilities/nodeDebug.kt b/core/src/main/kotlin/Utilities/nodeDebug.kt
deleted file mode 100644
index e89f88ec..00000000
--- a/core/src/main/kotlin/Utilities/nodeDebug.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-package org.jetbrains.dokka.Utilities
-
-import org.jetbrains.dokka.Model.DocumentationNode
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-
-const val DOWN = '\u2503'
-const val BRANCH = '\u2523'
-const val LAST = '\u2517'
-
-fun DocumentationNode.pretty(prefix: String = "", isLast: Boolean = true): String {
-    val nextPrefix = prefix + (if (isLast) ' ' else DOWN) + ' '
-
-    return prefix + (if (isLast) LAST else BRANCH) + this.toString() +
-            children.dropLast(1)
-                .map { it.pretty(nextPrefix, false) }
-                .plus(children.lastOrNull()?.pretty(nextPrefix))
-                .filterNotNull()
-                .takeIf { it.isNotEmpty() }
-                ?.joinToString(prefix = "\n", separator = "")
-                .orEmpty() + if (children.isEmpty()) "\n" else ""
-}
-
-//fun Any.genericPretty(prefix: String = "", isLast: Boolean = true): String {
-//    val nextPrefix = prefix + (if (isLast) ' ' else DOWN) + ' '
-//
-//    return prefix + (if (isLast) LAST else BRANCH) + this.stringify() +
-//            allChildren().dropLast(1)
-//                .map { it.genericPretty(nextPrefix, false) }
-//                .plus(allChildren().lastOrNull()?.genericPretty(nextPrefix))
-//                .filterNotNull()
-//                .takeIf { it.isNotEmpty() }
-//                ?.joinToString(prefix = "\n", separator = "")
-//                .orEmpty() + if (allChildren().isEmpty()) "\n" else ""
-//}
-private fun Any.stringify() = when(this) {
-    is ContentNode -> toString() + this.dci
-    is PageNode -> this.name + this::class.simpleName
-    else -> toString()
-}
-//private fun Any.allChildren() = when(this){
-//    is PageNode -> children + content
-//    is ContentBlock -> this.children
-//    is ContentHeader -> this.items
-//    is ContentStyle -> this.items
-//    is ContentSymbol -> this.parts
-//    is ContentComment -> this.parts
-//    is ContentGroup -> this.children
-//    is ContentList -> this.items
-//    else -> emptyList()
-//}
diff --git a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
new file mode 100644
index 00000000..30a51136
--- /dev/null
+++ b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
@@ -0,0 +1,454 @@
+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.MockComponentManager
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.OrderEnumerationHandler
+import com.intellij.openapi.roots.ProjectFileIndex
+import com.intellij.openapi.roots.ProjectRootManager
+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.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
+import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
+import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
+import org.jetbrains.kotlin.cli.jvm.config.*
+import org.jetbrains.kotlin.cli.jvm.index.JavaRoot
+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.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+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.load.java.structure.impl.JavaClassImpl
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.*
+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.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 java.io.File
+
+/**
+ * Kotlin as a service entry point
+ *
+ * Configures environment, analyses files and provides facilities to perform code processing without emitting bytecode
+ *
+ * $messageCollector: required by compiler infrastructure and will receive all compiler messages
+ * $body: optional and can be used to configure environment without creating local variable
+ */
+class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPlatform: Platform) : Disposable {
+    val configuration = CompilerConfiguration()
+
+    init {
+        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
+    }
+
+    fun createCoreEnvironment(): KotlinCoreEnvironment {
+        System.setProperty("idea.io.use.fallback", "true")
+
+        val configFiles = when (analysisPlatform) {
+            Platform.jvm, Platform.common -> EnvironmentConfigFiles.JVM_CONFIG_FILES
+            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 moduleManager = object : CoreModuleManager(environment.project, this) {
+            override fun getModules(): Array<out Module> = arrayOf(projectFileIndex.module)
+        }
+
+        CoreApplicationEnvironment.registerComponentInstance(projectComponentManager.picoContainer,
+                ModuleManager::class.java, moduleManager)
+
+        Extensions.registerAreaClass("IDEA_MODULE", null)
+        CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(),
+                OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java)
+
+        projectComponentManager.registerService(ProjectFileIndex::class.java,
+                projectFileIndex)
+        projectComponentManager.registerService(ProjectRootManager::class.java,
+                CoreProjectRootManager(projectFileIndex))
+        return environment
+    }
+
+    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())
+        }
+
+
+    fun createResolutionFacade(environment: KotlinCoreEnvironment): Pair<DokkaResolutionFacade, DokkaResolutionFacade> {
+
+        val projectContext = ProjectContext(environment.project)
+        val sourceFiles = environment.getSourceFiles()
+
+
+        val targetPlatform = when (analysisPlatform) {
+            Platform.js -> JsPlatform
+            Platform.common -> TargetPlatform.Common
+            Platform.native -> KonanPlatform
+            Platform.jvm -> JvmPlatform
+        }
+
+        val library = object : LibraryModuleInfo {
+            override val platform: TargetPlatform
+                get() = targetPlatform
+
+            override fun getLibraryRoots(): Collection<String> {
+                return classpath.map { it.absolutePath }
+            }
+
+            override val name: Name = Name.special("<library>")
+            override fun dependencies(): List<ModuleInfo> = listOf(this)
+        }
+        val module = object : ModuleInfo {
+            override val name: Name = Name.special("<module>")
+            override fun dependencies(): List<ModuleInfo> = listOf(this, library)
+        }
+
+        val sourcesScope = createSourceModuleSearchScope(environment.project, sourceFiles)
+        val modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo> = {
+            when (it) {
+                library -> ModuleContent(it, emptyList(), GlobalSearchScope.notScope(sourcesScope))
+                module -> ModuleContent(it, emptyList(), GlobalSearchScope.allScope(environment.project))
+                else -> throw IllegalArgumentException("Unexpected module info")
+            }
+        }
+
+        var builtIns: JvmBuiltIns? = null
+
+        val resolverForProject = when (analysisPlatform) {
+            Platform.jvm -> {
+                builtIns = JvmBuiltIns(projectContext.storageManager)
+                createJvmResolverForProject(projectContext, module, library, modulesContent, sourcesScope, builtIns)
+            }
+            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 created = DokkaResolutionFacade(environment.project, moduleDescriptor, resolverForModule)
+        val projectComponentManager = environment.project as MockComponentManager
+        projectComponentManager.registerService(KotlinCacheService::class.java, CoreKotlinCacheService(created))
+
+        return created to libraryResolutionFacade
+    }
+
+    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
+        )
+    }
+
+    private fun createJsResolverForProject(
+        projectContext: ProjectContext,
+        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
+        )
+    }
+
+    private fun createNativeResolverForProject(
+        projectContext: ProjectContext,
+        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
+        )
+
+    }
+
+    private fun createJvmResolverForProject(
+        projectContext: ProjectContext,
+        module: ModuleInfo,
+        library: LibraryModuleInfo,
+        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
+        sourcesScope: GlobalSearchScope,
+        builtIns: KotlinBuiltIns
+    ): ResolverForProjectImpl<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)
+                }
+
+                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)
+                    else -> throw IllegalArgumentException("Unexpected module info")
+                }
+            },
+            modulePlatforms = { JvmPlatform.multiTargetPlatform },
+            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
+            resolverForModuleFactoryByPlatform = { JvmAnalyzerFacade },
+            platformParameters = {
+                JvmPlatformParameters ({ content ->
+                    JvmPackagePartProvider(
+                        configuration.languageVersionSettings,
+                        content.moduleContentScope)
+                        .apply {
+                            addRoots(javaRoots, messageCollector)
+                        }
+                }, {
+                    val file = (it as JavaClassImpl).psi.containingFile.virtualFile
+                    if (file in sourcesScope)
+                        module
+                    else
+                        library
+                })
+            },
+            targetEnvironment = CompilerEnvironment,
+            builtIns = builtIns
+        )
+    }
+
+    fun loadLanguageVersionSettings(languageVersionString: String?, apiVersionString: String?) {
+        val languageVersion = LanguageVersion.fromVersionString(languageVersionString) ?: LanguageVersion.LATEST_STABLE
+        val apiVersion = apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
+        configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
+    }
+
+    /**
+     * Classpath for this environment.
+     */
+    val classpath: List<File>
+        get() = configuration.jvmClasspathRoots
+
+    /**
+     * Adds list of paths to classpath.
+     * $paths: collection of files to add
+     */
+    fun addClasspath(paths: List<File>) {
+        if (analysisPlatform == Platform.js) {
+            configuration.addAll(JSConfigurationKeys.LIBRARIES, paths.map { it.absolutePath })
+        }
+        configuration.addJvmClasspathRoots(paths)
+    }
+
+    /**
+     * Adds path to classpath.
+     * $path: path to add
+     */
+    fun addClasspath(path: File) {
+        if (analysisPlatform == Platform.js) {
+            configuration.add(JSConfigurationKeys.LIBRARIES, path.absolutePath)
+        }
+        configuration.addJvmClasspathRoot(path)
+    }
+
+    /**
+     * List of source roots for this environment.
+     */
+    val sources: List<String>
+        get() = configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
+                ?.filterIsInstance<KotlinSourceRoot>()
+                ?.map { it.path } ?: emptyList()
+
+    /**
+     * Adds list of paths to source roots.
+     * $list: collection of files to add
+     */
+    fun addSources(list: List<String>) {
+        list.forEach {
+            configuration.addKotlinSourceRoot(it)
+            val file = File(it)
+            if (file.isDirectory || file.extension == ".java") {
+                configuration.addJavaSourceRoot(file)
+            }
+        }
+    }
+
+    fun addRoots(list: List<ContentRoot>) {
+        configuration.addAll(CLIConfigurationKeys.CONTENT_ROOTS, list)
+    }
+
+    /**
+     * Disposes the environment and frees all associated resources.
+     */
+    override fun dispose() {
+        Disposer.dispose(this)
+    }
+}
+
+fun contentRootFromPath(path: String): ContentRoot {
+    val file = File(path)
+    return if (file.extension == "java") JavaSourceRoot(file, null) else KotlinSourceRoot(path, false)
+}
+
+
+class DokkaResolutionFacade(override val project: Project,
+                            override val moduleDescriptor: ModuleDescriptor,
+                            val resolverForModule: ResolverForModule) : ResolutionFacade {
+    override fun analyzeWithAllCompilerChecks(elements: Collection<KtElement>): AnalysisResult {
+        throw UnsupportedOperationException()
+    }
+
+    override fun <T : Any> tryGetFrontendService(element: PsiElement, serviceClass: Class<T>): T? {
+        return resolverForModule.componentProvider.tryGetService(serviceClass)
+    }
+
+    override fun resolveToDescriptor(declaration: KtDeclaration, bodyResolveMode: BodyResolveMode): DeclarationDescriptor {
+        return resolveSession.resolveToDescriptor(declaration)
+    }
+
+    override fun analyze(elements: Collection<KtElement>, bodyResolveMode: BodyResolveMode): BindingContext {
+        throw UnsupportedOperationException()
+    }
+
+    val resolveSession: ResolveSession get() = getFrontendService(ResolveSession::class.java)
+
+    override fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
+        if (element is KtDeclaration) {
+            val descriptor = resolveToDescriptor(element)
+            return object : BindingContext {
+                override fun <K : Any?, V : Any?> getKeys(p0: WritableSlice<K, V>?): Collection<K> {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun getType(p0: KtExpression): KotlinType? {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun <K : Any?, V : Any?> get(slice: ReadOnlySlice<K, V>?, key: K): V? {
+                    if (key != element) {
+                        throw UnsupportedOperationException()
+                    }
+                    return when {
+                        slice == BindingContext.DECLARATION_TO_DESCRIPTOR -> descriptor as V
+                        slice == BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER && (element as KtParameter).hasValOrVar() -> descriptor as V
+                        else -> null
+                    }
+                }
+
+                override fun getDiagnostics(): Diagnostics {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun addOwnDataTo(p0: BindingTrace, p1: Boolean) {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun <K : Any?, V : Any?> getSliceContents(p0: ReadOnlySlice<K, V>): ImmutableMap<K, V> {
+                    throw UnsupportedOperationException()
+                }
+
+            }
+        }
+        throw UnsupportedOperationException()
+    }
+
+    override fun <T : Any> getFrontendService(element: PsiElement, serviceClass: Class<T>): T {
+        throw UnsupportedOperationException()
+    }
+
+    override fun <T : Any> getFrontendService(serviceClass: Class<T>): T {
+        return resolverForModule.componentProvider.getService(serviceClass)
+    }
+
+    override fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
+        return resolverForModule.componentProvider.getService(serviceClass)
+    }
+
+    override fun <T : Any> getIdeService(serviceClass: Class<T>): T {
+        throw UnsupportedOperationException()
+    }
+
+}
diff --git a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt b/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
new file mode 100644
index 00000000..509c4e10
--- /dev/null
+++ b/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.psi.PsiFile
+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
+
+
+class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade) : KotlinCacheService {
+    override fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeByFile(file: PsiFile, platform: TargetPlatform): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacadeByModuleInfo(moduleInfo: ModuleInfo, platform: TargetPlatform): ResolutionFacade? {
+        return resolutionFacade
+    }
+
+    override fun getSuppressionCache(): KotlinSuppressCache {
+        throw UnsupportedOperationException()
+    }
+
+}
+
diff --git a/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt b/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
new file mode 100644
index 00000000..6863a266
--- /dev/null
+++ b/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
@@ -0,0 +1,568 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.components.BaseComponent
+import com.intellij.openapi.extensions.ExtensionPointName
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.projectRoots.Sdk
+import com.intellij.openapi.projectRoots.SdkAdditionalData
+import com.intellij.openapi.projectRoots.SdkModificator
+import com.intellij.openapi.projectRoots.SdkTypeId
+import com.intellij.openapi.roots.*
+import com.intellij.openapi.roots.impl.ProjectOrderEnumerator
+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.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileFilter
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.util.messages.MessageBus
+import org.jetbrains.jps.model.module.JpsModuleSourceRootType
+import org.jetbrains.kotlin.cli.common.config.ContentRoot
+import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
+import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
+import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
+import org.picocontainer.PicoContainer
+import java.io.File
+
+/**
+ * Workaround for the lack of ability to create a ProjectFileIndex implementation using only
+ * classes from projectModel-{api,impl}.
+ */
+class CoreProjectFileIndex(private val project: Project, contentRoots: List<ContentRoot>) : ProjectFileIndex, ModuleFileIndex {
+    override fun iterateContent(p0: ContentIterator, p1: VirtualFileFilter?): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator, p2: VirtualFileFilter?): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInLibrary(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    val sourceRoots = contentRoots.filter { it !is JvmClasspathRoot }
+    val classpathRoots = contentRoots.filterIsInstance<JvmClasspathRoot>()
+
+    val module: Module = object : UserDataHolderBase(), Module {
+        override fun isDisposed(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getOptionValue(p0: String): String? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun clearOption(p0: String) {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getName(): String = "<Dokka module>"
+
+        override fun getModuleWithLibrariesScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleWithDependentsScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleContentScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun isLoaded(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun setOption(p0: String, p1: String?) {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleWithDependenciesScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleWithDependenciesAndLibrariesScope(p0: Boolean): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getProject(): Project = this@CoreProjectFileIndex.project
+
+        override fun getModuleContentWithDependenciesScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleFilePath(): String {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleTestsWithDependentsScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleScope(p0: Boolean): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleRuntimeScope(p0: Boolean): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleFile(): VirtualFile? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> getExtensions(p0: ExtensionPointName<T>): Array<out T> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getComponent(p0: String): BaseComponent? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> getComponent(p0: Class<T>, p1: T): T {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> getComponent(interfaceClass: Class<T>): T? {
+            if (interfaceClass == ModuleRootManager::class.java) {
+                return moduleRootManager as T
+            }
+            throw UnsupportedOperationException()
+        }
+
+        override fun getDisposed(): Condition<*> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> getComponents(p0: Class<T>): Array<out T> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getPicoContainer(): PicoContainer {
+            throw UnsupportedOperationException()
+        }
+
+        override fun hasComponent(p0: Class<*>): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getMessageBus(): MessageBus {
+            throw UnsupportedOperationException()
+        }
+
+        override fun dispose() {
+            throw UnsupportedOperationException()
+        }
+    }
+
+    private val sdk: Sdk = object : Sdk, RootProvider {
+        override fun getFiles(rootType: OrderRootType): Array<out VirtualFile> = classpathRoots
+                .mapNotNull { StandardFileSystems.local().findFileByPath(it.file.path) }
+                .toTypedArray()
+
+        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
+            throw UnsupportedOperationException()
+        }
+
+        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener, p1: Disposable) {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getUrls(p0: OrderRootType): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun removeRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSdkModificator(): SdkModificator {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getName(): String = "<dokka SDK>"
+
+        override fun getRootProvider(): RootProvider = this
+
+        override fun getHomePath(): String? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getVersionString(): String? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSdkAdditionalData(): SdkAdditionalData? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun clone(): Any {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSdkType(): SdkTypeId {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getHomeDirectory(): VirtualFile? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> getUserData(p0: Key<T>): T? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> putUserData(p0: Key<T>, p1: T?) {
+            throw UnsupportedOperationException()
+        }
+    }
+
+    private val moduleSourceOrderEntry = object : ModuleSourceOrderEntry {
+        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getUrls(p0: OrderRootType): Array<String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
+            throw UnsupportedOperationException()
+        }
+
+
+        override fun getPresentableName(): String {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getOwnerModule(): Module = module
+
+
+        override fun isValid(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun compareTo(other: OrderEntry?): Int {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getRootModel(): ModuleRootModel = moduleRootManager
+
+        override fun isSynthetic(): Boolean {
+            throw UnsupportedOperationException()
+        }
+    }
+
+    private val sdkOrderEntry = object : JdkOrderEntry {
+        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getUrls(p0: OrderRootType): Array<String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getJdkName(): String? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getJdk(): Sdk = sdk
+
+        override fun getPresentableName(): String {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getOwnerModule(): Module {
+            throw UnsupportedOperationException()
+        }
+
+        override fun isValid(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getRootFiles(p0: OrderRootType): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getRootUrls(p0: OrderRootType): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun compareTo(other: OrderEntry?): Int {
+            throw UnsupportedOperationException()
+        }
+
+        override fun isSynthetic(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+    }
+
+    inner class MyModuleRootManager : ModuleRootManager() {
+        override fun getExternalSource(): ProjectModelExternalSource? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getExcludeRoots(): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getContentEntries(): Array<out ContentEntry> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getExcludeRootUrls(): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <R : Any?> processOrder(p0: RootPolicy<R>?, p1: R): R {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRoots(p0: Boolean): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRoots(): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRoots(p0: JpsModuleSourceRootType<*>): MutableList<VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getContentRoots(): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun orderEntries(): OrderEnumerator =
+                ProjectOrderEnumerator(project, null).using(object : RootModelProvider {
+                    override fun getModules(): Array<out Module> = arrayOf(module)
+
+                    override fun getRootModel(p0: Module): ModuleRootModel = this@MyModuleRootManager
+                })
+
+        override fun <T : Any?> getModuleExtension(p0: Class<T>): T {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getDependencyModuleNames(): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModule(): Module = this@CoreProjectFileIndex.module
+
+        override fun isSdkInherited(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getOrderEntries(): Array<out OrderEntry> = arrayOf(moduleSourceOrderEntry, sdkOrderEntry)
+
+        override fun getSourceRootUrls(): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRootUrls(p0: Boolean): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSdk(): Sdk? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getContentRootUrls(): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleDependencies(): Array<out Module> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleDependencies(p0: Boolean): Array<out Module> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModifiableModel(): ModifiableRootModel {
+            throw UnsupportedOperationException()
+        }
+
+        override fun isDependsOn(p0: Module?): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getFileIndex(): ModuleFileIndex {
+            return this@CoreProjectFileIndex
+        }
+
+        override fun getDependencies(): Array<out Module> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getDependencies(p0: Boolean): Array<out Module> {
+            throw UnsupportedOperationException()
+        }
+    }
+
+    val moduleRootManager = MyModuleRootManager()
+
+    override fun getContentRootForFile(p0: VirtualFile): VirtualFile? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentRootForFile(p0: VirtualFile, p1: Boolean): VirtualFile? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getPackageNameByDirectory(p0: VirtualFile): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInLibrarySource(file: VirtualFile): Boolean = false
+
+    override fun getClassRootForFile(file: VirtualFile): VirtualFile? =
+        classpathRoots.firstOrNull { it.contains(file) }?.let { StandardFileSystems.local().findFileByPath(it.file.path) }
+
+    override fun getOrderEntriesForFile(file: VirtualFile): List<OrderEntry> =
+        if (classpathRoots.contains(file)) listOf(sdkOrderEntry) else emptyList()
+
+    override fun isInLibraryClasses(file: VirtualFile): Boolean = classpathRoots.contains(file)
+
+    override fun isExcluded(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getSourceRootForFile(p0: VirtualFile): VirtualFile? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isUnderIgnored(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isLibraryClassFile(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getModuleForFile(file: VirtualFile): Module? =
+            if (sourceRoots.contains(file)) module else null
+
+    private fun List<ContentRoot>.contains(file: VirtualFile): Boolean = any { it.contains(file) }
+
+    override fun getModuleForFile(p0: VirtualFile, p1: Boolean): Module? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInSource(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isIgnored(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isContentSourceFile(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInSourceContent(file: VirtualFile): Boolean = sourceRoots.contains(file)
+
+    override fun iterateContent(p0: ContentIterator): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInContent(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInTestSourceContent(file: VirtualFile): Boolean = false
+
+    override fun isUnderSourceRootOfType(p0: VirtualFile, p1: MutableSet<out JpsModuleSourceRootType<*>>): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getOrderEntryForFile(p0: VirtualFile): OrderEntry? {
+        throw UnsupportedOperationException()
+    }
+}
+
+class CoreProjectRootManager(val projectFileIndex: CoreProjectFileIndex) : ProjectRootManager() {
+    override fun orderEntries(): OrderEnumerator {
+        throw UnsupportedOperationException()
+    }
+
+    override fun orderEntries(p0: MutableCollection<out Module>): OrderEnumerator {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentRootsFromAllModules(): Array<out VirtualFile>? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun setProjectSdk(p0: Sdk?) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun setProjectSdkName(p0: String?) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getModuleSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentSourceRoots(): Array<out VirtualFile> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getFileIndex(): ProjectFileIndex = projectFileIndex
+
+    override fun getProjectSdkName(): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getProjectSdk(): Sdk? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentRoots(): Array<out VirtualFile> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentRootUrls(): MutableList<String> {
+        throw UnsupportedOperationException()
+    }
+
+}
+
+fun ContentRoot.contains(file: VirtualFile) = when (this) {
+    is JvmContentRoot -> {
+        val path = if (file.fileSystem.protocol == StandardFileSystems.JAR_PROTOCOL)
+            StandardFileSystems.getVirtualFileForJar(file)?.path ?: file.path
+        else
+            file.path
+        File(path).startsWith(this.file.absoluteFile)
+    }
+    is KotlinSourceRoot -> File(file.path).startsWith(File(this.path).absoluteFile)
+    else -> false
+}
diff --git a/core/src/main/kotlin/analysis/DokkaAnalyzerFacades.kt b/core/src/main/kotlin/analysis/DokkaAnalyzerFacades.kt
new file mode 100644
index 00000000..c69ff645
--- /dev/null
+++ b/core/src/main/kotlin/analysis/DokkaAnalyzerFacades.kt
@@ -0,0 +1,164 @@
+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
new file mode 100644
index 00000000..2b60a639
--- /dev/null
+++ b/core/src/main/kotlin/analysis/JavaResolveExtension.kt
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:JvmName("JavaResolutionUtils")
+
+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.*
+import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+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.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
+
+// TODO: Remove that file
+
+@JvmOverloads
+fun PsiMethod.getJavaMethodDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    val method = originalElement as? PsiMethod ?: return null
+    if (method.containingClass == null || !Name.isValidIdentifier(method.name)) return null
+    val resolver = method.getJavaDescriptorResolver(resolutionFacade)
+    return when {
+        method.isConstructor -> resolver?.resolveConstructor(JavaConstructorImpl(method))
+        else -> resolver?.resolveMethod(JavaMethodImpl(method))
+    }
+}
+
+@JvmOverloads
+fun PsiClass.getJavaClassDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): ClassDescriptor? {
+    val psiClass = originalElement as? PsiClass ?: return null
+    return psiClass.getJavaDescriptorResolver(resolutionFacade)?.resolveClass(JavaClassImpl(psiClass))
+}
+
+@JvmOverloads
+fun PsiField.getJavaFieldDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): PropertyDescriptor? {
+    val field = originalElement as? PsiField ?: return null
+    return field.getJavaDescriptorResolver(resolutionFacade)?.resolveField(JavaFieldImpl(field))
+}
+
+@JvmOverloads
+fun PsiMember.getJavaMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    return when (this) {
+        is PsiEnumConstant -> containingClass?.getJavaClassDescriptor(resolutionFacade)
+        is PsiClass -> getJavaClassDescriptor(resolutionFacade)
+        is PsiMethod -> getJavaMethodDescriptor(resolutionFacade)
+        is PsiField -> getJavaFieldDescriptor(resolutionFacade)
+        else -> null
+    }
+}
+
+@JvmOverloads
+fun PsiMember.getJavaOrKotlinMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    val callable = unwrapped
+    return when (callable) {
+        is PsiMember -> getJavaMemberDescriptor(resolutionFacade)
+        is KtDeclaration -> {
+            val descriptor = resolutionFacade.resolveToDescriptor(callable)
+            if (descriptor is ClassDescriptor && this is PsiMethod) descriptor.unsubstitutedPrimaryConstructor else descriptor
+        }
+        else -> null
+    }
+}
+
+private fun PsiElement.getJavaDescriptorResolver(resolutionFacade: ResolutionFacade): JavaDescriptorResolver? {
+    return resolutionFacade.tryGetFrontendService(this, JavaDescriptorResolver::class.java)
+}
+
+private fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): DeclarationDescriptor? {
+    return getContainingScope(method)
+            ?.getContributedDescriptors(nameFilter = { true }, kindFilter = DescriptorKindFilter.CALLABLES)
+            ?.filterIsInstance<DeclarationDescriptorWithSource>()
+            ?.findByJavaElement(method)
+}
+
+private fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructor): ConstructorDescriptor? {
+    return resolveClass(constructor.containingClass)?.constructors?.findByJavaElement(constructor)
+}
+
+private fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescriptor? {
+    return getContainingScope(field)?.getContributedVariables(field.name, NoLookupLocation.FROM_IDE)?.findByJavaElement(field)
+}
+
+private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): MemberScope? {
+    val containingClass = resolveClass(member.containingClass)
+    return if (member.isStatic)
+        containingClass?.staticScope
+    else
+        containingClass?.defaultType?.memberScope
+}
+
+private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {
+    return firstOrNull { member ->
+        val memberJavaElement = (member.original.source as? JavaSourceElement)?.javaElement
+        when {
+            memberJavaElement == javaElement ->
+                true
+            memberJavaElement is JavaElementImpl<*> && javaElement is JavaElementImpl<*> ->
+                memberJavaElement.psi.isEquivalentTo(javaElement.psi)
+            else ->
+                false
+        }
+    }
+}
+
+fun PsiElement.javaResolutionFacade() =
+    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatform)!!
diff --git a/core/src/main/kotlin/markdown/MarkdownProcessor.kt b/core/src/main/kotlin/markdown/MarkdownProcessor.kt
new file mode 100644
index 00000000..1304d58e
--- /dev/null
+++ b/core/src/main/kotlin/markdown/MarkdownProcessor.kt
@@ -0,0 +1,53 @@
+package org.jetbrains.dokka.markdown
+
+import org.intellij.markdown.IElementType
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.ast.ASTNode
+import org.intellij.markdown.ast.LeafASTNode
+import org.intellij.markdown.ast.getTextInNode
+import org.intellij.markdown.flavours.commonmark.CommonMarkFlavourDescriptor
+import org.intellij.markdown.parser.MarkdownParser
+
+class MarkdownNode(val node: ASTNode, val parent: MarkdownNode?, val markdown: String) {
+    val children: List<MarkdownNode> = node.children.map { MarkdownNode(it, this, markdown) }
+    val type: IElementType get() = node.type
+    val text: String get() = node.getTextInNode(markdown).toString()
+    fun child(type: IElementType): MarkdownNode? = children.firstOrNull { it.type == type }
+
+    val previous get() = parent?.children?.getOrNull(parent.children.indexOf(this) - 1)
+
+    override fun toString(): String = StringBuilder().apply { presentTo(this) }.toString()
+}
+
+fun MarkdownNode.visit(action: (MarkdownNode, () -> Unit) -> Unit) {
+    action(this) {
+        for (child in children) {
+            child.visit(action)
+        }
+    }
+}
+
+fun MarkdownNode.toTestString(): String {
+    val sb = StringBuilder()
+    var level = 0
+    visit { node, visitChildren ->
+        sb.append(" ".repeat(level * 2))
+        node.presentTo(sb)
+        sb.appendln()
+        level++
+        visitChildren()
+        level--
+    }
+    return sb.toString()
+}
+
+private fun MarkdownNode.presentTo(sb: StringBuilder) {
+    sb.append(type.toString())
+    sb.append(":" + text.replace("w\n", "\u23CE"))
+}
+
+fun parseMarkdown(markdown: String): MarkdownNode {
+    if (markdown.isEmpty())
+        return MarkdownNode(LeafASTNode(MarkdownElementTypes.MARKDOWN_FILE, 0, 0), null, markdown)
+    return MarkdownNode(MarkdownParser(CommonMarkFlavourDescriptor()).buildMarkdownTreeFromString(markdown), null, markdown)
+}
diff --git a/core/src/main/kotlin/model/DocumentationNode.kt b/core/src/main/kotlin/model/DocumentationNode.kt
new file mode 100644
index 00000000..77225eca
--- /dev/null
+++ b/core/src/main/kotlin/model/DocumentationNode.kt
@@ -0,0 +1,162 @@
+package org.jetbrains.dokka.model
+
+import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
+
+class Module(val packages: List<Package>) : DocumentationNode() {
+    override val dri: DRI = DRI.topLevel
+    override val children: List<Package> = packages
+    override val extra: MutableSet<Extra> = mutableSetOf()
+}
+
+class Package(
+    override val dri: DRI,
+    override val functions: List<Function>,
+    override val properties: List<Property>,
+    override val classes: List<Class>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : ScopeNode() {
+    override val name = dri.packageName.orEmpty()
+}
+
+class Class(
+    override val dri: DRI,
+    override val name: String,
+    val kind: ClassKind,
+    val constructors: List<Function>,
+    override val functions: List<Function>,
+    override val properties: List<Property>,
+    override val classes: List<Class>,
+    override val expected: ClassPlatformInfo?,
+    override val actual: List<ClassPlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : ScopeNode() {
+    val inherited by lazy { platformInfo.mapNotNull { (it as? ClassPlatformInfo)?.inherited }.flatten() }
+}
+
+class Function(
+    override val dri: DRI,
+    override val name: String,
+    val returnType: TypeWrapper?,
+    val isConstructor: Boolean,
+    override val receiver: Parameter?,
+    val parameters: List<Parameter>,
+    override val expected: PlatformInfo?,
+    override val actual: List<PlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : CallableNode() {
+    override val children: List<Parameter>
+        get() = listOfNotNull(receiver) + parameters
+}
+
+class Property(
+    override val dri: DRI,
+    override val name: String,
+    override val receiver: Parameter?,
+    override val expected: PlatformInfo?,
+    override val actual: List<PlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : CallableNode() {
+    override val children: List<Parameter>
+        get() = listOfNotNull(receiver)
+}
+
+// TODO: treat named Parameters and receivers differently
+class Parameter(
+    override val dri: DRI,
+    override val name: String?,
+    val type: TypeWrapper,
+    override val actual: List<PlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : DocumentationNode() {
+    override val children: List<DocumentationNode>
+        get() = emptyList()
+}
+
+interface PlatformInfo {
+    val docTag: KDocTag?
+    val links: Map<String, DRI>
+    val platformData: List<PlatformData>
+}
+
+class BasePlatformInfo(
+    override val docTag: KDocTag?,
+    override val links: Map<String, DRI>,
+    override val platformData: List<PlatformData>) : PlatformInfo {
+
+    override fun equals(other: Any?): Boolean =
+        other is PlatformInfo && (
+                docTag?.text == other.docTag?.text &&
+                        links == other.links)
+
+    override fun hashCode(): Int =
+        listOf(docTag?.text, links).hashCode()
+}
+
+class ClassPlatformInfo(
+    val info: PlatformInfo,
+    val inherited: List<DRI>) : PlatformInfo by info
+
+abstract class DocumentationNode {
+    open val expected: PlatformInfo? = null
+    open val actual: List<PlatformInfo> = emptyList()
+    open val name: String? = null
+    val platformInfo by lazy { listOfNotNull(expected) + actual }
+    val platformData by lazy { platformInfo.flatMap { it.platformData }.toSet() }
+
+    abstract val dri: DRI
+
+    abstract val children: List<DocumentationNode>
+
+    override fun toString(): String {
+        return "${javaClass.simpleName}($dri)" + briefDocstring.takeIf { it.isNotBlank() }?.let { " [$it]" }.orEmpty()
+    }
+
+    override fun equals(other: Any?) = other is DocumentationNode && this.dri == other.dri
+
+    override fun hashCode() = dri.hashCode()
+
+    val commentsData: List<Pair<String, Map<String, DRI>>>
+        get() = platformInfo.mapNotNull { it.docTag?.let { tag -> Pair(tag.getContent(), it.links) } }
+
+    val briefDocstring: String
+        get() = platformInfo.firstOrNull()?.docTag?.getContent().orEmpty().shorten(40)
+
+    open val extra: MutableSet<Extra> = mutableSetOf()
+}
+
+abstract class ScopeNode : DocumentationNode() {
+    abstract val functions: List<Function>
+    abstract val properties: List<Property>
+    abstract val classes: List<Class>
+
+    override val children: List<DocumentationNode>
+        get() = functions + properties + classes
+}
+
+abstract class CallableNode : DocumentationNode() {
+    abstract val receiver: Parameter?
+}
+
+private fun String.shorten(maxLength: Int) = lineSequence().first().let {
+    if (it.length != length || it.length > maxLength) it.take(maxLength - 3) + "..." else it
+}
+
+interface TypeWrapper {
+    val constructorFqName: String?
+    val constructorNamePathSegments: List<String>
+    val arguments: List<KotlinTypeWrapper>
+    val dri: DRI?
+}
+interface ClassKind
+
+fun DocumentationNode.dfs(predicate: (DocumentationNode) -> Boolean): DocumentationNode? =
+    if (predicate(this)) {
+        this
+    } else {
+        this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull()
+    }
+
+interface Extra
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt b/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
index 72b5ead2..369c1edb 100644
--- a/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
+++ b/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
@@ -2,7 +2,7 @@ package org.jetbrains.dokka.pages
 
 import org.intellij.markdown.MarkdownElementTypes
 import org.intellij.markdown.MarkdownTokenTypes
-import org.jetbrains.dokka.MarkdownNode
+import org.jetbrains.dokka.markdown.MarkdownNode
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.plugability.DokkaContext
 
diff --git a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
index fe4736b7..cd96ff79 100644
--- a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
+++ b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
@@ -1,8 +1,7 @@
 package org.jetbrains.dokka.pages
 
-import org.jetbrains.dokka.MarkdownNode
+import org.jetbrains.dokka.markdown.MarkdownNode
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.plugability.DokkaContext
 
 interface MarkdownToContentConverter {
     fun buildContent(
diff --git a/core/src/main/kotlin/pages/PageBuilder.kt b/core/src/main/kotlin/pages/PageBuilder.kt
index d20635a4..92e2c5fe 100644
--- a/core/src/main/kotlin/pages/PageBuilder.kt
+++ b/core/src/main/kotlin/pages/PageBuilder.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.pages
 
-import org.jetbrains.dokka.Model.*
-import org.jetbrains.dokka.Model.Function
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Function
 
 class DefaultPageBuilder(
     override val rootContentGroup: RootContentBuilder
diff --git a/core/src/main/kotlin/pages/PageContentBuilder.kt b/core/src/main/kotlin/pages/PageContentBuilder.kt
index 2341a59d..3e852306 100644
--- a/core/src/main/kotlin/pages/PageContentBuilder.kt
+++ b/core/src/main/kotlin/pages/PageContentBuilder.kt
@@ -1,12 +1,12 @@
 package org.jetbrains.dokka.pages
 
-import org.jetbrains.dokka.DokkaLogger
-import org.jetbrains.dokka.Model.DocumentationNode
-import org.jetbrains.dokka.Model.Function
-import org.jetbrains.dokka.Model.Parameter
-import org.jetbrains.dokka.Model.TypeWrapper
+import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.dokka.model.DocumentationNode
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.model.Parameter
+import org.jetbrains.dokka.model.TypeWrapper
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.parseMarkdown
+import org.jetbrains.dokka.markdown.parseMarkdown
 
 class DefaultPageContentBuilder(
     private val dri: DRI,
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index cf5bf453..e8b66f4a 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.pages
 
-import org.jetbrains.dokka.Model.DocumentationNode
+import org.jetbrains.dokka.model.DocumentationNode
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.links.DRI
 
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 31c56728..7b1c1306 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.plugability
 
-import org.jetbrains.dokka.DokkaLogger
+import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.pages.PlatformData
 import java.io.File
diff --git a/core/src/main/kotlin/renderers/HtmlRenderer.kt b/core/src/main/kotlin/renderers/HtmlRenderer.kt
index 46548699..c04a18b4 100644
--- a/core/src/main/kotlin/renderers/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/HtmlRenderer.kt
@@ -1,13 +1,11 @@
 package org.jetbrains.dokka.renderers
 
-import org.jetbrains.dokka.htmlEscape
+import org.jetbrains.dokka.utilities.htmlEscape
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.resolvers.LocationProvider
 import java.io.File
 import java.net.URL
-import java.nio.file.Path
-import java.nio.file.Paths
 
 open class HtmlRenderer(
     fileWriter: FileWriter,
diff --git a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
index ec5aa29a..5139b3c1 100644
--- a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
+++ b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
@@ -2,7 +2,7 @@ package org.jetbrains.dokka.resolvers
 
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.htmlEscape
+import org.jetbrains.dokka.utilities.htmlEscape
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
diff --git a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
index 19aeef92..4ffa4295 100644
--- a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
+++ b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.dokka.transformers.descriptors
 
-import org.jetbrains.dokka.DokkaResolutionFacade
-import org.jetbrains.dokka.Model.*
-import org.jetbrains.dokka.Model.ClassKind
-import org.jetbrains.dokka.Model.Function
+import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.ClassKind
+import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.links.Callable
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.withClass
diff --git a/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
index d08aba21..bd9359ee 100644
--- a/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
+++ b/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.transformers.descriptors
 
-import org.jetbrains.dokka.Model.Module
-import org.jetbrains.dokka.Model.Package
+import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
index 46ba2816..2b00c582 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.transformers.documentation
 
-import org.jetbrains.dokka.Model.*
-import org.jetbrains.dokka.Model.Function
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.plugability.DokkaContext
 
 internal object DefaultDocumentationNodeMerger : DocumentationNodeMerger {
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
index 236d0864..c6813ef8 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.transformers.documentation
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.pages.DefaultPageBuilder
 import org.jetbrains.dokka.pages.DefaultPageContentBuilder
 import org.jetbrains.dokka.pages.ModulePageNode
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
index 0423f47c..25be625e 100644
--- a/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.transformers.documentation
 
-import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface DocumentationNodeMerger {
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentationNodeTransformer.kt b/core/src/main/kotlin/transformers/documentation/DocumentationNodeTransformer.kt
index 8ac4a7c2..d6358f07 100644
--- a/core/src/main/kotlin/transformers/documentation/DocumentationNodeTransformer.kt
+++ b/core/src/main/kotlin/transformers/documentation/DocumentationNodeTransformer.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.transformers.documentation
 
-import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface DocumentationNodeTransformer {
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
index ffe34226..08c26b19 100644
--- a/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
+++ b/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
@@ -1,10 +1,7 @@
 package org.jetbrains.dokka.transformers.documentation
 
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.Model.DocumentationNode
-import org.jetbrains.dokka.Model.Module
+import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface DocumentationToPageTranslator {
diff --git a/core/src/main/kotlin/utilities/DokkaLogging.kt b/core/src/main/kotlin/utilities/DokkaLogging.kt
new file mode 100644
index 00000000..6eb7867b
--- /dev/null
+++ b/core/src/main/kotlin/utilities/DokkaLogging.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.dokka.utilities
+
+interface DokkaLogger {
+    fun debug(message: String)
+    fun info(message: String)
+    fun progress(message: String)
+    fun warn(message: String)
+    fun error(message: String)
+}
+
+object DokkaConsoleLogger : DokkaLogger {
+    var warningCount: Int = 0
+
+    override fun debug(message: String)= println(message)
+
+    override fun progress(message: String) = println("PROGRESS: $message")
+
+    override fun info(message: String) = println(message)
+
+    override fun warn(message: String) = println("WARN: $message").also { warningCount++ }
+
+    override fun error(message: String) = println("ERROR: $message")
+
+    fun report() {
+        if (warningCount > 0) {
+            println("generation completed with $warningCount warnings")
+        } else {
+            println("generation completed successfully")
+        }
+    }
+}
diff --git a/core/src/main/kotlin/utilities/Html.kt b/core/src/main/kotlin/utilities/Html.kt
new file mode 100644
index 00000000..9dc032f6
--- /dev/null
+++ b/core/src/main/kotlin/utilities/Html.kt
@@ -0,0 +1,12 @@
+package org.jetbrains.dokka.utilities
+
+import java.net.URLEncoder
+
+
+/**
+ * Replaces symbols reserved in HTML with their respective entities.
+ * Replaces & with &amp;, < with &lt; and > with &gt;
+ */
+fun String.htmlEscape(): String = replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+fun String.urlEncoded(): String = URLEncoder.encode(this, "UTF-8")
\ No newline at end of file
diff --git a/core/src/main/kotlin/utilities/Path.kt b/core/src/main/kotlin/utilities/Path.kt
new file mode 100644
index 00000000..00e2aa60
--- /dev/null
+++ b/core/src/main/kotlin/utilities/Path.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.dokka.utilities
+
+import java.io.File
+
+fun File.appendExtension(extension: String) = if (extension.isEmpty()) this else File(path + "." + extension)
diff --git a/core/src/main/kotlin/utilities/ServiceLocator.kt b/core/src/main/kotlin/utilities/ServiceLocator.kt
new file mode 100644
index 00000000..00c9ae9f
--- /dev/null
+++ b/core/src/main/kotlin/utilities/ServiceLocator.kt
@@ -0,0 +1,97 @@
+package org.jetbrains.dokka.utilities
+
+import java.io.File
+import java.net.URISyntaxException
+import java.net.URL
+import java.util.*
+import java.util.jar.JarFile
+import java.util.zip.ZipEntry
+
+data class ServiceDescriptor(val name: String, val category: String, val description: String?, val className: String)
+
+class ServiceLookupException(message: String) : Exception(message)
+
+object ServiceLocator {
+    fun <T : Any> lookup(clazz: Class<T>, category: String, implementationName: String): T {
+        val descriptor = lookupDescriptor(category, implementationName)
+        return lookup(clazz, descriptor)
+    }
+
+    fun <T : Any> lookup(
+        clazz: Class<T>,
+        descriptor: ServiceDescriptor
+    ): T {
+        val loadedClass = javaClass.classLoader.loadClass(descriptor.className)
+        val constructor = loadedClass.constructors.firstOrNull { it.parameterTypes.isEmpty() } ?: throw ServiceLookupException("Class ${descriptor.className} has no corresponding constructor")
+
+        val implementationRawType: Any =
+            if (constructor.parameterTypes.isEmpty()) constructor.newInstance() else constructor.newInstance(constructor)
+
+        if (!clazz.isInstance(implementationRawType)) {
+            throw ServiceLookupException("Class ${descriptor.className} is not a subtype of ${clazz.name}")
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        return implementationRawType as T
+    }
+
+    private fun lookupDescriptor(category: String, implementationName: String): ServiceDescriptor {
+        val properties = javaClass.classLoader.getResourceAsStream("dokka/$category/$implementationName.properties")?.use { stream ->
+            Properties().let { properties ->
+                properties.load(stream)
+                properties
+            }
+        } ?: throw ServiceLookupException("No implementation with name $implementationName found in category $category")
+
+        val className = properties["class"]?.toString() ?: throw ServiceLookupException("Implementation $implementationName has no class configured")
+
+        return ServiceDescriptor(implementationName, category, properties["description"]?.toString(), className)
+    }
+
+    fun URL.toFile(): File {
+        assert(protocol == "file")
+
+        return try {
+            File(toURI())
+        } catch (e: URISyntaxException) { //Try to handle broken URLs, with unescaped spaces
+            File(path)
+        }
+    }
+
+    fun allServices(category: String): List<ServiceDescriptor> {
+        val entries = this.javaClass.classLoader.getResources("dokka/$category")?.toList() ?: emptyList()
+
+        return entries.flatMap {
+            when (it.protocol) {
+                "file" -> it.toFile().listFiles()?.filter { it.extension == "properties" }?.map { lookupDescriptor(category, it.nameWithoutExtension) } ?: emptyList()
+                "jar" -> {
+                    val file = JarFile(URL(it.file.substringBefore("!")).toFile())
+                    try {
+                        val jarPath = it.file.substringAfterLast("!").removePrefix("/").removeSuffix("/")
+                        file.entries()
+                                .asSequence()
+                                .filter { entry -> !entry.isDirectory && entry.path == jarPath && entry.extension == "properties" }
+                                .map { entry ->
+                                    lookupDescriptor(category, entry.fileName.substringBeforeLast("."))
+                                }.toList()
+                    } finally {
+                        file.close()
+                    }
+                }
+                else -> emptyList<ServiceDescriptor>()
+            }
+        }
+    }
+}
+
+inline fun <reified T : Any> ServiceLocator.lookup(category: String, implementationName: String): T = lookup(T::class.java, category, implementationName)
+inline fun <reified T : Any> ServiceLocator.lookup(desc: ServiceDescriptor): T = lookup(T::class.java, desc)
+
+private val ZipEntry.fileName: String
+    get() = name.substringAfterLast("/", name)
+
+private val ZipEntry.path: String
+    get() = name.substringBeforeLast("/", "").removePrefix("/")
+
+private val ZipEntry.extension: String?
+    get() = fileName.let { fn -> if ("." in fn) fn.substringAfterLast(".") else null }
diff --git a/core/src/main/kotlin/utilities/Uri.kt b/core/src/main/kotlin/utilities/Uri.kt
new file mode 100644
index 00000000..089b3cff
--- /dev/null
+++ b/core/src/main/kotlin/utilities/Uri.kt
@@ -0,0 +1,40 @@
+package org.jetbrains.dokka.utilities
+
+import java.net.URI
+
+
+fun URI.relativeTo(uri: URI): URI {
+    // Normalize paths to remove . and .. segments
+    val base = uri.normalize()
+    val child = this.normalize()
+
+    fun StringBuilder.appendRelativePath() {
+        // Split paths into segments
+        var bParts = base.path.split('/').dropLastWhile { it.isEmpty() }
+        val cParts = child.path.split('/').dropLastWhile { it.isEmpty() }
+
+        // Discard trailing segment of base path
+        if (bParts.isNotEmpty() && !base.path.endsWith("/")) {
+            bParts = bParts.dropLast(1)
+        }
+
+        // Compute common prefix
+        val commonPartsSize = bParts.zip(cParts).takeWhile { (basePart, childPart) -> basePart == childPart }.count()
+        bParts.drop(commonPartsSize).joinTo(this, separator = "") { "../" }
+        cParts.drop(commonPartsSize).joinTo(this, separator = "/")
+    }
+
+    return URI.create(buildString {
+        if (base.path != child.path) {
+            appendRelativePath()
+        }
+        child.rawQuery?.let {
+            append("?")
+            append(it)
+        }
+        child.rawFragment?.let {
+            append("#")
+            append(it)
+        }
+    })
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/utilities/nodeDebug.kt b/core/src/main/kotlin/utilities/nodeDebug.kt
new file mode 100644
index 00000000..3290202e
--- /dev/null
+++ b/core/src/main/kotlin/utilities/nodeDebug.kt
@@ -0,0 +1,50 @@
+package org.jetbrains.dokka.utilities
+
+import org.jetbrains.dokka.model.DocumentationNode
+import org.jetbrains.dokka.pages.*
+
+const val DOWN = '\u2503'
+const val BRANCH = '\u2523'
+const val LAST = '\u2517'
+
+fun DocumentationNode.pretty(prefix: String = "", isLast: Boolean = true): String {
+    val nextPrefix = prefix + (if (isLast) ' ' else DOWN) + ' '
+
+    return prefix + (if (isLast) LAST else BRANCH) + this.toString() +
+            children.dropLast(1)
+                .map { it.pretty(nextPrefix, false) }
+                .plus(children.lastOrNull()?.pretty(nextPrefix))
+                .filterNotNull()
+                .takeIf { it.isNotEmpty() }
+                ?.joinToString(prefix = "\n", separator = "")
+                .orEmpty() + if (children.isEmpty()) "\n" else ""
+}
+
+//fun Any.genericPretty(prefix: String = "", isLast: Boolean = true): String {
+//    val nextPrefix = prefix + (if (isLast) ' ' else DOWN) + ' '
+//
+//    return prefix + (if (isLast) LAST else BRANCH) + this.stringify() +
+//            allChildren().dropLast(1)
+//                .map { it.genericPretty(nextPrefix, false) }
+//                .plus(allChildren().lastOrNull()?.genericPretty(nextPrefix))
+//                .filterNotNull()
+//                .takeIf { it.isNotEmpty() }
+//                ?.joinToString(prefix = "\n", separator = "")
+//                .orEmpty() + if (allChildren().isEmpty()) "\n" else ""
+//}
+private fun Any.stringify() = when(this) {
+    is ContentNode -> toString() + this.dci
+    is PageNode -> this.name + this::class.simpleName
+    else -> toString()
+}
+//private fun Any.allChildren() = when(this){
+//    is PageNode -> children + content
+//    is ContentBlock -> this.children
+//    is ContentHeader -> this.items
+//    is ContentStyle -> this.items
+//    is ContentSymbol -> this.parts
+//    is ContentComment -> this.parts
+//    is ContentGroup -> this.children
+//    is ContentList -> this.items
+//    else -> emptyList()
+//}
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index c177218f..64d52b82 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -1,9 +1,8 @@
 package org.jetbrains.dokka.xml
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.DokkaConsoleLogger
-import org.jetbrains.dokka.Model.DocumentationNode
-import org.jetbrains.dokka.Model.dfs
+import org.jetbrains.dokka.model.DocumentationNode
+import org.jetbrains.dokka.model.dfs
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
diff --git a/runners/ant/src/main/kotlin/ant/dokka.kt b/runners/ant/src/main/kotlin/ant/dokka.kt
index 4bde902a..1395af31 100644
--- a/runners/ant/src/main/kotlin/ant/dokka.kt
+++ b/runners/ant/src/main/kotlin/ant/dokka.kt
@@ -7,6 +7,7 @@ import org.apache.tools.ant.types.Path
 import org.apache.tools.ant.types.Reference
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
+import org.jetbrains.dokka.utilities.DokkaLogger
 import java.io.File
 
 class AntLogger(val task: Task): DokkaLogger {
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index 32ce762d..2daac470 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.dokka
 
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
+import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import java.io.File
 import java.net.MalformedURLException
 import java.net.URL
@@ -94,12 +95,12 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
 
     override val languageVersion: String? by parser.stringOption(
         listOf("-languageVersion"),
-        "Language Version to pass to Kotlin Analysis",
+        "Language Version to pass to Kotlin analysis",
         null)
 
     override val apiVersion: String? by parser.stringOption(
         listOf("-apiVersion"),
-        "Kotlin Api Version to pass to Kotlin Analysis",
+        "Kotlin Api Version to pass to Kotlin analysis",
         null
     )
 
-- 
cgit 


From dd017a44ed7baae83f4f09a92d9691231f424eaa Mon Sep 17 00:00:00 2001
From: BarkingBad <32793002+BarkingBad@users.noreply.github.com>
Date: Fri, 13 Dec 2019 14:01:25 +0100
Subject: Add abstract structure for MD/HTML comments and MD parser

---
 core/build.gradle                                  |   2 +-
 core/src/main/kotlin/model/Documentable.kt         | 166 +++++++++++++++
 core/src/main/kotlin/model/DocumentationNode.kt    | 162 ---------------
 core/src/main/kotlin/model/doc/DocNode.kt          |  74 +++++++
 core/src/main/kotlin/model/doc/DocType.kt          |  18 ++
 .../src/main/kotlin/model/doc/DocumentationNode.kt |   3 +
 .../pages/DefaultMarkdownToContentConverter.kt     | 229 ---------------------
 .../main/kotlin/pages/DocNodeToContentConverter.kt |  82 ++++++++
 .../kotlin/pages/MarkdownToContentConverter.kt     |   4 +-
 core/src/main/kotlin/pages/PageBuilder.kt          |  23 ++-
 core/src/main/kotlin/pages/PageContentBuilder.kt   |  26 +--
 core/src/main/kotlin/pages/PageNodes.kt            |  22 +-
 core/src/main/kotlin/parsers/HtmlParser.kt         |  89 ++++++++
 core/src/main/kotlin/parsers/MarkdownParser.kt     | 206 ++++++++++++++++++
 core/src/main/kotlin/parsers/Parser.kt             |  44 ++++
 .../factories/DocNodesFromIElementFactory.kt       |  36 ++++
 .../parsers/factories/DocNodesFromStringFactory.kt |  76 +++++++
 .../main/kotlin/plugability/DefaultExtensions.kt   |   4 +-
 core/src/main/kotlin/renderers/HtmlRenderer.kt     |   9 +-
 .../DefaultDescriptorToDocumentationTranslator.kt  |  38 +---
 .../DefaultDocumentationNodeMerger.kt              |   9 +-
 core/src/main/kotlin/utilities/nodeDebug.kt        |   4 +-
 core/src/test/kotlin/markdown/ParserTest.kt        |   8 +-
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt   |   2 +-
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |   8 +-
 25 files changed, 865 insertions(+), 479 deletions(-)
 create mode 100644 core/src/main/kotlin/model/Documentable.kt
 delete mode 100644 core/src/main/kotlin/model/DocumentationNode.kt
 create mode 100644 core/src/main/kotlin/model/doc/DocNode.kt
 create mode 100644 core/src/main/kotlin/model/doc/DocType.kt
 create mode 100644 core/src/main/kotlin/model/doc/DocumentationNode.kt
 delete mode 100644 core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
 create mode 100644 core/src/main/kotlin/pages/DocNodeToContentConverter.kt
 create mode 100644 core/src/main/kotlin/parsers/HtmlParser.kt
 create mode 100644 core/src/main/kotlin/parsers/MarkdownParser.kt
 create mode 100644 core/src/main/kotlin/parsers/Parser.kt
 create mode 100644 core/src/main/kotlin/parsers/factories/DocNodesFromIElementFactory.kt
 create mode 100644 core/src/main/kotlin/parsers/factories/DocNodesFromStringFactory.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/build.gradle b/core/build.gradle
index 20ff8760..f9ab0f37 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -28,7 +28,7 @@ dependencies {
     compile "org.jetbrains.kotlin:kotlin-reflect:$bundled_kotlin_compiler_version"
 
     compile group: 'com.google.inject', name: 'guice', version: '3.0'
-    compile "org.jsoup:jsoup:1.8.3"
+    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"
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
new file mode 100644
index 00000000..9f676a1e
--- /dev/null
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -0,0 +1,166 @@
+package org.jetbrains.dokka.model
+
+import model.doc.*
+import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.PlatformData
+
+class Module(val packages: List<Package>) : Documentable() {
+    override val dri: DRI = DRI.topLevel
+    override val children: List<Package> = packages
+    override val extra: MutableSet<Extra> = mutableSetOf()
+}
+
+class Package(
+    override val dri: DRI,
+    override val functions: List<Function>,
+    override val properties: List<Property>,
+    override val classes: List<Class>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : ScopeNode() {
+    override val name = dri.packageName.orEmpty()
+}
+
+class Class(
+    override val dri: DRI,
+    override val name: String,
+    val kind: ClassKind,
+    val constructors: List<Function>,
+    override val functions: List<Function>,
+    override val properties: List<Property>,
+    override val classes: List<Class>,
+    override val expected: ClassPlatformInfo?,
+    override val actual: List<ClassPlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : ScopeNode() {
+    val inherited by lazy { platformInfo.mapNotNull { (it as? ClassPlatformInfo)?.inherited }.flatten() }
+}
+
+class Function(
+    override val dri: DRI,
+    override val name: String,
+    val returnType: TypeWrapper?,
+    val isConstructor: Boolean,
+    override val receiver: Parameter?,
+    val parameters: List<Parameter>,
+    override val expected: PlatformInfo?,
+    override val actual: List<PlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : CallableNode() {
+    override val children: List<Parameter>
+        get() = listOfNotNull(receiver) + parameters
+}
+
+class Property(
+    override val dri: DRI,
+    override val name: String,
+    override val receiver: Parameter?,
+    override val expected: PlatformInfo?,
+    override val actual: List<PlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : CallableNode() {
+    override val children: List<Parameter>
+        get() = listOfNotNull(receiver)
+}
+
+// TODO: treat named Parameters and receivers differently
+class Parameter(
+    override val dri: DRI,
+    override val name: String?,
+    val type: TypeWrapper,
+    override val actual: List<PlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : Documentable() {
+    override val children: List<Documentable>
+        get() = emptyList()
+}
+
+interface PlatformInfo {
+    val documentationNode: DocumentationNode
+    val platformData: List<PlatformData>
+}
+
+class BasePlatformInfo(
+    override val documentationNode: DocumentationNode,
+    override val platformData: List<PlatformData>) : PlatformInfo {
+
+    override fun equals(other: Any?): Boolean =
+        other is PlatformInfo && documentationNode == other.documentationNode
+
+    override fun hashCode(): Int =
+        documentationNode.hashCode()
+}
+
+class ClassPlatformInfo(
+    val info: PlatformInfo,
+    val inherited: List<DRI>) : PlatformInfo by info
+
+abstract class Documentable {
+    open val expected: PlatformInfo? = null
+    open val actual: List<PlatformInfo> = emptyList()
+    open val name: String? = null
+    val platformInfo by lazy { listOfNotNull(expected) + actual }
+    val platformData by lazy { platformInfo.flatMap { it.platformData }.toSet() }
+    abstract val dri: DRI
+
+    abstract val children: List<Documentable>
+
+    override fun toString(): String {
+        return "${javaClass.simpleName}($dri)" + briefDocstring.takeIf { it.isNotBlank() }?.let { " [$it]" }.orEmpty()
+    }
+
+    override fun equals(other: Any?) = other is Documentable && this.dri == other.dri
+
+    override fun hashCode() = dri.hashCode()
+
+
+
+    val commentsData: List<DocumentationNode>
+        get() = platformInfo.map { it.documentationNode }
+
+    val briefDocstring: String
+        get() = docNodeSummary(platformInfo.firstOrNull()?.documentationNode?.children?.firstOrNull()?.root ?: Text(body = "")).shorten(40)
+
+    private fun docNodeSummary(docNode: DocNode): String {
+        if(docNode.children.isEmpty() && docNode is Text)
+            return docNode.body
+
+        return docNode.children.joinToString(" ") { docNodeSummary(it) }
+    }
+
+    open val extra: MutableSet<Extra> = mutableSetOf()
+}
+
+abstract class ScopeNode : Documentable() {
+    abstract val functions: List<Function>
+    abstract val properties: List<Property>
+    abstract val classes: List<Class>
+
+    override val children: List<Documentable>
+        get() = functions + properties + classes
+}
+
+abstract class CallableNode : Documentable() {
+    abstract val receiver: Parameter?
+}
+
+private fun String.shorten(maxLength: Int) = lineSequence().first().let {
+    if (it.length != length || it.length > maxLength) it.take(maxLength - 3) + "..." else it
+}
+
+interface TypeWrapper {
+    val constructorFqName: String?
+    val constructorNamePathSegments: List<String>
+    val arguments: List<KotlinTypeWrapper>
+    val dri: DRI?
+}
+interface ClassKind
+
+fun Documentable.dfs(predicate: (Documentable) -> Boolean): Documentable? =
+    if (predicate(this)) {
+        this
+    } else {
+        this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull()
+    }
+
+interface Extra
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/DocumentationNode.kt b/core/src/main/kotlin/model/DocumentationNode.kt
deleted file mode 100644
index 77225eca..00000000
--- a/core/src/main/kotlin/model/DocumentationNode.kt
+++ /dev/null
@@ -1,162 +0,0 @@
-package org.jetbrains.dokka.model
-
-import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
-
-class Module(val packages: List<Package>) : DocumentationNode() {
-    override val dri: DRI = DRI.topLevel
-    override val children: List<Package> = packages
-    override val extra: MutableSet<Extra> = mutableSetOf()
-}
-
-class Package(
-    override val dri: DRI,
-    override val functions: List<Function>,
-    override val properties: List<Property>,
-    override val classes: List<Class>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : ScopeNode() {
-    override val name = dri.packageName.orEmpty()
-}
-
-class Class(
-    override val dri: DRI,
-    override val name: String,
-    val kind: ClassKind,
-    val constructors: List<Function>,
-    override val functions: List<Function>,
-    override val properties: List<Property>,
-    override val classes: List<Class>,
-    override val expected: ClassPlatformInfo?,
-    override val actual: List<ClassPlatformInfo>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : ScopeNode() {
-    val inherited by lazy { platformInfo.mapNotNull { (it as? ClassPlatformInfo)?.inherited }.flatten() }
-}
-
-class Function(
-    override val dri: DRI,
-    override val name: String,
-    val returnType: TypeWrapper?,
-    val isConstructor: Boolean,
-    override val receiver: Parameter?,
-    val parameters: List<Parameter>,
-    override val expected: PlatformInfo?,
-    override val actual: List<PlatformInfo>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : CallableNode() {
-    override val children: List<Parameter>
-        get() = listOfNotNull(receiver) + parameters
-}
-
-class Property(
-    override val dri: DRI,
-    override val name: String,
-    override val receiver: Parameter?,
-    override val expected: PlatformInfo?,
-    override val actual: List<PlatformInfo>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : CallableNode() {
-    override val children: List<Parameter>
-        get() = listOfNotNull(receiver)
-}
-
-// TODO: treat named Parameters and receivers differently
-class Parameter(
-    override val dri: DRI,
-    override val name: String?,
-    val type: TypeWrapper,
-    override val actual: List<PlatformInfo>,
-    override val extra: MutableSet<Extra> = mutableSetOf()
-) : DocumentationNode() {
-    override val children: List<DocumentationNode>
-        get() = emptyList()
-}
-
-interface PlatformInfo {
-    val docTag: KDocTag?
-    val links: Map<String, DRI>
-    val platformData: List<PlatformData>
-}
-
-class BasePlatformInfo(
-    override val docTag: KDocTag?,
-    override val links: Map<String, DRI>,
-    override val platformData: List<PlatformData>) : PlatformInfo {
-
-    override fun equals(other: Any?): Boolean =
-        other is PlatformInfo && (
-                docTag?.text == other.docTag?.text &&
-                        links == other.links)
-
-    override fun hashCode(): Int =
-        listOf(docTag?.text, links).hashCode()
-}
-
-class ClassPlatformInfo(
-    val info: PlatformInfo,
-    val inherited: List<DRI>) : PlatformInfo by info
-
-abstract class DocumentationNode {
-    open val expected: PlatformInfo? = null
-    open val actual: List<PlatformInfo> = emptyList()
-    open val name: String? = null
-    val platformInfo by lazy { listOfNotNull(expected) + actual }
-    val platformData by lazy { platformInfo.flatMap { it.platformData }.toSet() }
-
-    abstract val dri: DRI
-
-    abstract val children: List<DocumentationNode>
-
-    override fun toString(): String {
-        return "${javaClass.simpleName}($dri)" + briefDocstring.takeIf { it.isNotBlank() }?.let { " [$it]" }.orEmpty()
-    }
-
-    override fun equals(other: Any?) = other is DocumentationNode && this.dri == other.dri
-
-    override fun hashCode() = dri.hashCode()
-
-    val commentsData: List<Pair<String, Map<String, DRI>>>
-        get() = platformInfo.mapNotNull { it.docTag?.let { tag -> Pair(tag.getContent(), it.links) } }
-
-    val briefDocstring: String
-        get() = platformInfo.firstOrNull()?.docTag?.getContent().orEmpty().shorten(40)
-
-    open val extra: MutableSet<Extra> = mutableSetOf()
-}
-
-abstract class ScopeNode : DocumentationNode() {
-    abstract val functions: List<Function>
-    abstract val properties: List<Property>
-    abstract val classes: List<Class>
-
-    override val children: List<DocumentationNode>
-        get() = functions + properties + classes
-}
-
-abstract class CallableNode : DocumentationNode() {
-    abstract val receiver: Parameter?
-}
-
-private fun String.shorten(maxLength: Int) = lineSequence().first().let {
-    if (it.length != length || it.length > maxLength) it.take(maxLength - 3) + "..." else it
-}
-
-interface TypeWrapper {
-    val constructorFqName: String?
-    val constructorNamePathSegments: List<String>
-    val arguments: List<KotlinTypeWrapper>
-    val dri: DRI?
-}
-interface ClassKind
-
-fun DocumentationNode.dfs(predicate: (DocumentationNode) -> Boolean): DocumentationNode? =
-    if (predicate(this)) {
-        this
-    } else {
-        this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull()
-    }
-
-interface Extra
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/doc/DocNode.kt b/core/src/main/kotlin/model/doc/DocNode.kt
new file mode 100644
index 00000000..0c643551
--- /dev/null
+++ b/core/src/main/kotlin/model/doc/DocNode.kt
@@ -0,0 +1,74 @@
+package model.doc
+
+import org.jetbrains.dokka.links.DRI
+
+sealed class DocNode(
+    val children: List<DocNode>,
+    val params: Map<String, String>
+)
+
+class A(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
+class Big(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class B(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
+class BlockQuote(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())       : DocNode(children, params)
+class Cite(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Code(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Dd(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class Dfn(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class Dir(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class Div(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class Dl(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class Dt(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class Em(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class Font(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Footer(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
+class Frame(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
+class FrameSet(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())         : DocNode(children, params)
+class H1(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class H2(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class H3(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class H4(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class H5(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class H6(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class Head(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Header(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
+class Html(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class I(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
+class IFrame(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
+class Img(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class Input(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
+class Li(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class Link(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Listing(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())          : DocNode(children, params)
+class Main(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Menu(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Meta(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Nav(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class NoFrames(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())         : DocNode(children, params)
+class NoScript(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())         : DocNode(children, params)
+class Ol(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class P(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
+class Pre(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class Script(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
+class Section(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())          : DocNode(children, params)
+class Small(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
+class Span(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
+class Strong(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
+class Sub(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class Sup(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class Table(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
+class Text(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap(), val body: String = "") : DocNode(children, params)
+class TBody(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
+class Td(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class TFoot(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
+class Th(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class THead(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
+class Title(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
+class Tr(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class Tt(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class U(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
+class Ul(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
+class Var(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
+class DocumentationLink(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap(), val dri: DRI) : DocNode(children, params)
+class HorizontalRule()                                                                                  : DocNode(emptyList(), emptyMap())
+class CustomNode(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())       : DocNode(children, params)
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/doc/DocType.kt b/core/src/main/kotlin/model/doc/DocType.kt
new file mode 100644
index 00000000..0888876e
--- /dev/null
+++ b/core/src/main/kotlin/model/doc/DocType.kt
@@ -0,0 +1,18 @@
+package model.doc
+
+sealed class DocType(val root: DocNode)
+class Description(root: DocNode) : DocType(root)
+class Author(root: DocNode) : DocType(root)
+class Version(root: DocNode) : DocType(root)
+class Since(root: DocNode) : DocType(root)
+class See(root: DocNode, val name: String) : DocType(root)
+class Param(root: DocNode, val name: String) : DocType(root)
+class Return(root: DocNode) : DocType(root)
+class Receiver(root: DocNode) : DocType(root)
+class Constructor(root: DocNode) : DocType(root)
+class Throws(root: DocNode, val name: String) : DocType(root)
+class Sample(root: DocNode, val name: String) : DocType(root)
+class Deprecated(root: DocNode) : DocType(root)
+class Property(root: DocNode, val name: String) : DocType(root)
+class Suppress(root: DocNode) : DocType(root)
+class CustomTag(root: DocNode, val name: String) : DocType(root)
diff --git a/core/src/main/kotlin/model/doc/DocumentationNode.kt b/core/src/main/kotlin/model/doc/DocumentationNode.kt
new file mode 100644
index 00000000..73424616
--- /dev/null
+++ b/core/src/main/kotlin/model/doc/DocumentationNode.kt
@@ -0,0 +1,3 @@
+package model.doc
+
+data class DocumentationNode(val children: List<DocType>)
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt b/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
deleted file mode 100644
index bb8a826d..00000000
--- a/core/src/main/kotlin/pages/DefaultMarkdownToContentConverter.kt
+++ /dev/null
@@ -1,229 +0,0 @@
-package org.jetbrains.dokka.pages
-
-import org.intellij.markdown.MarkdownElementTypes
-import org.intellij.markdown.MarkdownTokenTypes
-import org.jetbrains.dokka.markdown.MarkdownNode
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.plugability.DokkaContext
-
-class DefaultMarkdownToContentConverter(
-    private val context: DokkaContext
-) : MarkdownToContentConverter {
-    override fun buildContent(
-        node: MarkdownNode,
-        dci: DCI,
-        platforms: Set<PlatformData>,
-        links: Map<String, DRI>,
-        styles: Set<Style>,
-        extras: Set<Extra>
-
-    ): List<ContentNode> {
-//    println(tree.toTestString())
-
-        fun buildChildren(node: MarkdownNode, newStyles: Set<Style> = emptySet(), newExtras: Set<Extra> = emptySet()) =
-            node.children.flatMap {
-                buildContent(it, dci, platforms, links, styles + newStyles, extras + newExtras)
-            }.coalesceText(platforms, styles + newStyles, extras + newExtras)
-
-        fun buildHeader(level: Int) =
-            ContentHeader(buildChildren(node), level, dci, platforms, styles)
-
-        return when (node.type) {
-            MarkdownElementTypes.ATX_1 -> listOf(buildHeader(1))
-            MarkdownElementTypes.ATX_2 -> listOf(buildHeader(2))
-            MarkdownElementTypes.ATX_3 -> listOf(buildHeader(3))
-            MarkdownElementTypes.ATX_4 -> listOf(buildHeader(4))
-            MarkdownElementTypes.ATX_5 -> listOf(buildHeader(5))
-            MarkdownElementTypes.ATX_6 -> listOf(buildHeader(6))
-            MarkdownElementTypes.UNORDERED_LIST -> listOf(
-                ContentList(
-                    buildChildren(node),
-                    false,
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            MarkdownElementTypes.ORDERED_LIST -> listOf(
-                ContentList(
-                    buildChildren(node),
-                    true,
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            MarkdownElementTypes.LIST_ITEM -> TODO()
-            MarkdownElementTypes.STRONG,
-            MarkdownTokenTypes.EMPH,
-            MarkdownElementTypes.EMPH ->
-                buildChildren(node, setOf(TextStyle.Strong))
-            // TODO
-            MarkdownElementTypes.CODE_SPAN -> TODO()
-//            val startDelimiter = node.child(MarkdownTokenTypes.BACKTICK)?.text
-//            if (startDelimiter != null) {
-//                val text = node.text.substring(startDelimiter.length).removeSuffix(startDelimiter)
-//                val codeSpan = ContentCode().apply { append(ContentText(text)) }
-//                parent.append(codeSpan)
-//            }
-
-            MarkdownElementTypes.CODE_BLOCK,
-            MarkdownElementTypes.CODE_FENCE -> {
-                val language = node.child(MarkdownTokenTypes.FENCE_LANG)?.text?.trim() ?: ""
-                listOf(ContentCode(buildChildren(node), language, dci, platforms, styles, extras)) // TODO
-            }
-            MarkdownElementTypes.PARAGRAPH -> buildChildren(node, newStyles = setOf(TextStyle.Paragraph))
-
-            MarkdownElementTypes.INLINE_LINK -> {
-//            val linkTextNode = node.child(MarkdownElementTypes.LINK_TEXT)
-//            val destination = node.child(MarkdownElementTypes.LINK_DESTINATION)
-//            if (linkTextNode != null) {
-//                if (destination != null) {
-//                    val link = ContentExternalLink(destination.text)
-//                    renderLinkTextTo(linkTextNode, link, linkResolver)
-//                    parent.append(link)
-//                } else {
-//                    val link = ContentExternalLink(linkTextNode.getLabelText())
-//                    renderLinkTextTo(linkTextNode, link, linkResolver)
-//                    parent.append(link)
-//                }
-//            }
-                //TODO: Linking!!!
-//            ContentLink()
-                TODO()
-            }
-            MarkdownElementTypes.SHORT_REFERENCE_LINK,
-            MarkdownElementTypes.FULL_REFERENCE_LINK -> {
-                val destinationNode = node.children.find { it.type == MarkdownElementTypes.LINK_DESTINATION }
-                        ?: node.children.first { it.type == MarkdownElementTypes.LINK_LABEL }
-                val destination = destinationNode.children.find { it.type == MarkdownTokenTypes.TEXT }?.text
-                        ?: destinationNode.text
-                links[destination]?.let { dri ->
-                    listOf(
-                        ContentDRILink( // TODO: differentiate between KDoc link and some external link (http://...)
-                            buildChildren(node),
-                            dri,
-                            DCI(dri, ContentKind.Symbol),
-                            platforms,
-                            styles,
-                            extras
-                        )
-                    )
-                } ?: let {
-                    context.logger.error("Apparently there is no link resolved for $destination")
-                    emptyList<ContentNode>()
-                }
-            }
-            MarkdownTokenTypes.WHITE_SPACE -> {
-                // Don't append first space if start of header (it is added during formatting later)
-                //                   v
-                //               #### Some Heading
-//            if (nodeStack.peek() !is ContentHeading || node.parent?.children?.first() != node) {
-//                parent.append(ContentText(node.text))
-//            }
-                listOf(ContentText(" ", dci, platforms, styles, extras))
-            }
-            MarkdownTokenTypes.EOL -> {
-//            if ((keepEol(nodeStack.peek()) && node.parent?.children?.last() != node) ||
-//                // Keep extra blank lines when processing lists (affects Markdown formatting)
-//                (processingList(nodeStack.peek()) && node.previous?.type == MarkdownTokenTypes.EOL)) {
-//                parent.append(ContentText(node.text))
-//            }
-                listOf(ContentText(" ", dci, platforms, styles, extras))
-            }
-
-            MarkdownTokenTypes.CODE_LINE -> {
-                listOf(ContentText(node.text, dci, platforms, styles, extras)) // TODO check
-//            if (parent is ContentBlockCode) {
-//                parent.append(content)
-//            } else {
-//                parent.append(ContentBlockCode().apply { append(content) })
-//            }
-            }
-
-            MarkdownTokenTypes.TEXT ->
-//            fun createEntityOrText(text: String): ContentNode {
-//                if (text == "&amp;" || text == "&quot;" || text == "&lt;" || text == "&gt;") {
-//                    return ContentEntity(text)
-//                }
-//                if (text == "&") {
-//                    return ContentEntity("&amp;")
-//                }
-//                val decodedText = EntityConverter.replaceEntities(text, true, true)
-//                if (decodedText != text) {
-//                    return ContentEntity(text)
-//                }
-//                return ContentText(text)
-//            }
-//
-//            parent.append(createEntityOrText(node.text))
-                listOf(ContentText(node.text, dci, platforms, styles, extras)) // TODO
-
-            MarkdownTokenTypes.COLON,
-            MarkdownTokenTypes.SINGLE_QUOTE,
-            MarkdownTokenTypes.DOUBLE_QUOTE,
-            MarkdownTokenTypes.LT,
-            MarkdownTokenTypes.GT,
-            MarkdownTokenTypes.LPAREN,
-            MarkdownTokenTypes.RPAREN,
-            MarkdownTokenTypes.LBRACKET,
-            MarkdownTokenTypes.RBRACKET,
-            MarkdownTokenTypes.EXCLAMATION_MARK,
-            MarkdownTokenTypes.BACKTICK,
-            MarkdownTokenTypes.CODE_FENCE_CONTENT -> {
-                listOf(ContentText(node.text, dci, platforms, styles, extras))
-            }
-
-            MarkdownElementTypes.LINK_DEFINITION -> TODO()
-
-            MarkdownTokenTypes.EMAIL_AUTOLINK ->
-                listOf(
-                    ContentResolvedLink(
-                        listOf(ContentText(node.text, dci, platforms, styles, extras)),
-                        "mailto:${node.text}",
-                        dci, platforms, styles, extras
-                    )
-                )
-
-            else -> buildChildren(node)
-        }
-    }
-
-    private fun Collection<ContentNode>.coalesceText(
-        platforms: Set<PlatformData>,
-        styles: Set<Style>,
-        extras: Set<Extra>
-    ) =
-        this
-            .sliceWhen { prev, next -> prev::class != next::class }
-            .flatMap { nodes ->
-                when (nodes.first()) {
-                    is ContentText -> listOf(
-                        ContentText(
-                            nodes.joinToString("") { (it as ContentText).text },
-                            nodes.first().dci, platforms, styles, extras
-                        )
-                    )
-                    else -> nodes
-                }
-            }
-}
-
-fun <T> Collection<T>.sliceWhen(predicate: (before: T, after: T) -> Boolean): Collection<Collection<T>> {
-    val newCollection = mutableListOf<Collection<T>>()
-    var currentSlice = mutableListOf<T>()
-    for ((prev, next) in this.windowed(2, 1, false)) {
-        currentSlice.add(prev)
-        if (predicate(prev, next)) {
-            newCollection.add(currentSlice)
-            currentSlice = mutableListOf<T>()
-        }
-    }
-    if (this.isNotEmpty()) {
-        currentSlice.add(this.last())
-        newCollection.add(currentSlice)
-    }
-    return newCollection
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/DocNodeToContentConverter.kt b/core/src/main/kotlin/pages/DocNodeToContentConverter.kt
new file mode 100644
index 00000000..dce69114
--- /dev/null
+++ b/core/src/main/kotlin/pages/DocNodeToContentConverter.kt
@@ -0,0 +1,82 @@
+package org.jetbrains.dokka.pages
+
+import model.doc.*
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.jetbrains.dokka.markdown.MarkdownNode
+import org.jetbrains.dokka.plugability.DokkaContext
+
+class DocNodeToContentConverter(
+    private val context: DokkaContext
+) : MarkdownToContentConverter {
+    override fun buildContent(
+        docNode: DocNode,
+        dci: DCI,
+        platforms: Set<PlatformData>,
+        styles: Set<Style>,
+        extras: Set<Extra>
+
+    ): List<ContentNode> {
+
+        fun buildChildren(docNode: DocNode, newStyles: Set<Style> = emptySet(), newExtras: Set<Extra> = emptySet()) =
+            docNode.children.flatMap {
+                buildContent(it, dci, platforms, styles + newStyles, extras + newExtras)
+            }
+
+        fun buildHeader(level: Int) =
+            listOf(ContentHeader(buildChildren(docNode), level, dci, platforms, styles, extras))
+
+        fun buildList(ordered: Boolean) =
+            listOf(ContentList(buildChildren(docNode), ordered, dci, platforms, styles, extras))
+
+        return when (docNode) {
+            is H1 -> buildHeader(1)
+            is H2 -> buildHeader(2)
+            is H3 -> buildHeader(3)
+            is H4 -> buildHeader(4)
+            is H5 -> buildHeader(5)
+            is H6 -> buildHeader(6)
+            is Ul -> buildList(false)
+            is Ol -> buildList(true)
+            is Li -> buildChildren(docNode)
+            is B -> buildChildren(docNode, setOf(TextStyle.Strong))
+            is I -> buildChildren(docNode, setOf(TextStyle.Italic))
+            is P -> buildChildren(docNode, newStyles = setOf(TextStyle.Paragraph))
+            is A -> listOf(
+                ContentResolvedLink(
+                    buildChildren(docNode),
+                    docNode.params.get("href")!!,
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is DocumentationLink -> listOf(
+                ContentDRILink(
+                    buildChildren(docNode),
+                    docNode.dri,
+                    DCI(docNode.dri, ContentKind.Symbol),
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is BlockQuote -> throw NotImplementedError("Implement DocNotToContent BlockQuote!")
+            is Code -> listOf(
+                ContentCode(
+                    buildChildren(docNode),
+                    "",
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is Img -> throw NotImplementedError("Implement DocNotToContent Img!")
+            is HorizontalRule -> listOf(ContentText("", dci, platforms, setOf()))
+            is Text -> listOf(ContentText(docNode.body, dci, platforms, styles, extras))
+            else -> buildChildren(docNode)
+        }
+    }
+}
diff --git a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
index cd96ff79..321a3f02 100644
--- a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
+++ b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
@@ -1,14 +1,14 @@
 package org.jetbrains.dokka.pages
 
+import model.doc.DocNode
 import org.jetbrains.dokka.markdown.MarkdownNode
 import org.jetbrains.dokka.links.DRI
 
 interface MarkdownToContentConverter {
     fun buildContent(
-        node: MarkdownNode,
+        docNode: DocNode,
         dci: DCI,
         platforms: Set<PlatformData>,
-        links: Map<String, DRI> = emptyMap(),
         styles: Set<Style> = emptySet(),
         extras: Set<Extra> = emptySet()
     ): List<ContentNode>
diff --git a/core/src/main/kotlin/pages/PageBuilder.kt b/core/src/main/kotlin/pages/PageBuilder.kt
index 92e2c5fe..8951219a 100644
--- a/core/src/main/kotlin/pages/PageBuilder.kt
+++ b/core/src/main/kotlin/pages/PageBuilder.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.pages
 
+import model.doc.DocType
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Function
 
@@ -29,7 +30,7 @@ class DefaultPageBuilder(
             else -> throw IllegalStateException("$m should not be present here")
         }
 
-    private fun group(node: DocumentationNode, content: PageContentBuilderFunction) =
+    private fun group(node: Documentable, content: PageContentBuilderFunction) =
         rootContentGroup(node, ContentKind.Main, content)
 
     private fun contentForModule(m: Module) = group(m) {
@@ -60,7 +61,13 @@ class DefaultPageBuilder(
             header(2) { text("SuperInterfaces") }
             linkTable(it)
         }
-        c.commentsData.forEach { (doc, links) -> comment(doc, links) }
+        c.commentsData.forEach {
+            it.children.forEach {
+                header(3) { text(it.toHeaderString()) }
+                comment(it.root)
+                text("\n")
+            }
+        }
         block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) {
             link(it.name, it.dri)
             signature(it)
@@ -71,20 +78,26 @@ class DefaultPageBuilder(
             signature(it)
             text(it.briefDocstring)
         }
+        block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) {
+            link(it.name, it.dri)
+            text(it.briefDocstring)
+        }
     }
 
     private fun contentForFunction(f: Function) = group(f) {
         header(1) { text(f.name) }
         signature(f)
-        f.commentsData.forEach { (doc, links) -> markdown(doc, links) }
+        f.commentsData.forEach { it.children.forEach { comment(it.root) } }
         block("Parameters", 2, ContentKind.Parameters, f.children, f.platformData) {
             text(it.name ?: "<receiver>")
-            it.commentsData.forEach { (doc, links) -> markdown(doc, links) }
+            it.commentsData.forEach { it.children.forEach { comment(it.root) } }
         }
     }
+
+    private fun DocType.toHeaderString() = this.javaClass.toGenericString().split('.').last()
 }
 
-typealias RootContentBuilder = (DocumentationNode, Kind, PageContentBuilderFunction) -> ContentGroup
+typealias RootContentBuilder = (Documentable, Kind, PageContentBuilderFunction) -> ContentGroup
 
 interface PageBuilder {
     val rootContentGroup: RootContentBuilder
diff --git a/core/src/main/kotlin/pages/PageContentBuilder.kt b/core/src/main/kotlin/pages/PageContentBuilder.kt
index 3e852306..e3c924d1 100644
--- a/core/src/main/kotlin/pages/PageContentBuilder.kt
+++ b/core/src/main/kotlin/pages/PageContentBuilder.kt
@@ -1,12 +1,12 @@
 package org.jetbrains.dokka.pages
 
+import model.doc.DocNode
 import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.dokka.model.DocumentationNode
+import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.model.Parameter
 import org.jetbrains.dokka.model.TypeWrapper
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.markdown.parseMarkdown
 
 class DefaultPageContentBuilder(
     private val dri: DRI,
@@ -73,7 +73,7 @@ class DefaultPageContentBuilder(
         )
     }
 
-    override fun <T : DocumentationNode> block(
+    override fun <T : Documentable> block(
         name: String,
         level: Int,
         kind: Kind,
@@ -127,27 +127,18 @@ class DefaultPageContentBuilder(
         )
     }
 
-    override fun comment(raw: String, links: Map<String, DRI>) {
+    override fun comment(docNode: DocNode) {
         contents += group(ContentKind.Comment) {
             with(this as DefaultPageContentBuilder) {
                 contents += markdownConverter.buildContent(
-                    parseMarkdown(raw),
+                    docNode,
                     DCI(dri, ContentKind.Comment),
-                    platformData,
-                    links
+                    platformData
                 )
             }
         }
     }
 
-    override fun markdown(raw: String, links: Map<String, DRI>) {
-        contents += markdownConverter.buildContent(
-            parseMarkdown(raw), DCI(dri, ContentKind.Sample),
-            platformData,
-            links
-        )
-    }
-
     fun group(kind: Kind, block: PageContentBuilderFunction): ContentGroup =
         group(dri, platformData, kind, block)
 
@@ -200,8 +191,7 @@ interface PageContentBuilder {
     fun link(text: String, address: DRI, kind: Kind = ContentKind.Symbol)
     fun link(address: DRI, kind: Kind = ContentKind.Symbol, block: PageContentBuilderFunction)
     fun linkTable(elements: List<DRI>)
-    fun comment(raw: String, links: Map<String, DRI>)
-    fun markdown(raw: String, links: Map<String, DRI>)
+    fun comment(docNode: DocNode)
     fun header(level: Int, block: PageContentBuilderFunction)
     fun <T> list(
         elements: List<T>,
@@ -211,7 +201,7 @@ interface PageContentBuilder {
         operation: PageContentBuilder.(T) -> Unit
     )
 
-    fun <T : DocumentationNode> block(
+    fun <T : Documentable> block(
         name: String,
         level: Int,
         kind: Kind,
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index f1ad430f..0aa439de 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.pages
 
-import org.jetbrains.dokka.model.DocumentationNode
+import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.links.DRI
 import java.util.*
@@ -9,7 +9,7 @@ interface PageNode {
     val name: String
     val content: ContentNode
     val dri: DRI
-    val documentationNode: DocumentationNode?
+    val documentable: Documentable?
     val embeddedResources: List<String>
     val children: List<PageNode>
 
@@ -24,7 +24,8 @@ interface PageNode {
 class ModulePageNode(
     override val name: String,
     override val content: ContentNode,
-    override val documentationNode: DocumentationNode?,
+
+    override val documentable: Documentable?,
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
 ) : PageNode {
@@ -37,7 +38,7 @@ class ModulePageNode(
         children: List<PageNode>
     ): ModulePageNode =
         if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
-        else ModulePageNode(name, content, documentationNode, children, embeddedResources)
+        else ModulePageNode(name, content, documentable, children, embeddedResources)
 
     private fun PageNode.transformNode(operation: (PageNode) -> PageNode): PageNode =
         operation(this).let { newNode ->
@@ -64,7 +65,8 @@ class PackagePageNode(
     override val name: String,
     override val content: ContentNode,
     override val dri: DRI,
-    override val documentationNode: DocumentationNode?,
+
+    override val documentable: Documentable?,
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
 ) : PageNode {
@@ -76,14 +78,14 @@ class PackagePageNode(
         children: List<PageNode>
     ): PackagePageNode =
         if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
-        else PackagePageNode(name, content, dri, documentationNode, children, embeddedResources)
+        else PackagePageNode(name, content, dri, documentable, children, embeddedResources)
 }
 
 class ClassPageNode(
     override val name: String,
     override val content: ContentNode,
     override val dri: DRI,
-    override val documentationNode: DocumentationNode?,
+    override val documentable: Documentable?,
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
 ) : PageNode {
@@ -95,14 +97,14 @@ class ClassPageNode(
         children: List<PageNode>
     ): ClassPageNode =
         if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
-        else ClassPageNode(name, content, dri, documentationNode, children, embeddedResources)
+        else ClassPageNode(name, content, dri, documentable, children, embeddedResources)
 }
 
 class MemberPageNode(
     override val name: String,
     override val content: ContentNode,
     override val dri: DRI,
-    override val documentationNode: DocumentationNode?,
+    override val documentable: Documentable?,
     override val children: List<PageNode> = emptyList(),
     override val embeddedResources: List<String> = listOf()
 ) : PageNode {
@@ -114,7 +116,7 @@ class MemberPageNode(
         children: List<PageNode>
     ): MemberPageNode =
         if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
-        else MemberPageNode(name, content, dri, documentationNode, children, embeddedResources)
+        else MemberPageNode(name, content, dri, documentable, children, embeddedResources)
 }
 
 data class PlatformData(val platformType: Platform, val targets: List<String>) {
diff --git a/core/src/main/kotlin/parsers/HtmlParser.kt b/core/src/main/kotlin/parsers/HtmlParser.kt
new file mode 100644
index 00000000..30f882b1
--- /dev/null
+++ b/core/src/main/kotlin/parsers/HtmlParser.kt
@@ -0,0 +1,89 @@
+package parsers
+
+import model.doc.*
+import org.jetbrains.dokka.parsers.factories.DocNodesFromStringFactory
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Node
+import org.jsoup.select.NodeFilter
+import org.jsoup.select.NodeTraversor
+
+class HtmlParser : Parser() {
+
+    inner class NodeFilterImpl : NodeFilter {
+
+        private val nodesCache: MutableMap<Int, MutableList<DocNode>> = mutableMapOf()
+        private var currentDepth = 0
+
+        fun collect(): DocNode = nodesCache[currentDepth]!![0]
+
+        override fun tail(node: Node?, depth: Int): NodeFilter.FilterResult {
+            val nodeName = node!!.nodeName()
+            val nodeAttributes = node.attributes()
+
+            if(nodeName in listOf("#document", "html", "head"))
+                return NodeFilter.FilterResult.CONTINUE
+
+            val body: String
+            val params: Map<String, String>
+
+
+            if(nodeName != "#text") {
+                body = ""
+                params = nodeAttributes.map { it.key to it.value }.toMap()
+            } else {
+                body = nodeAttributes["#text"]
+                params = emptyMap()
+            }
+
+            val docNode = if(depth < currentDepth) {
+                DocNodesFromStringFactory.getInstance(nodeName, nodesCache.getOrDefault(currentDepth, mutableListOf()).toList(), params, body).also {
+                    nodesCache[currentDepth] = mutableListOf()
+                    currentDepth = depth
+                }
+            } else {
+                DocNodesFromStringFactory.getInstance(nodeName, emptyList(), params, body)
+            }
+
+            nodesCache.getOrDefault(depth, mutableListOf()) += docNode
+            return NodeFilter.FilterResult.CONTINUE
+        }
+
+        override fun head(node: Node?, depth: Int): NodeFilter.FilterResult {
+
+            val nodeName = node!!.nodeName()
+
+            if(currentDepth < depth) {
+                currentDepth = depth
+                nodesCache[currentDepth] = mutableListOf()
+            }
+
+            if(nodeName in listOf("#document", "html", "head"))
+                return NodeFilter.FilterResult.CONTINUE
+
+            return NodeFilter.FilterResult.CONTINUE
+        }
+    }
+
+
+    private fun htmlToDocNode(string: String): DocNode {
+        val document = Jsoup.parse(string)
+        val nodeFilterImpl = NodeFilterImpl()
+        NodeTraversor.filter(nodeFilterImpl, document.root())
+        return nodeFilterImpl.collect()
+    }
+
+    private fun replaceLinksWithHrefs(javadoc: String): String = Regex("\\{@link .*?}").replace(javadoc) {
+        val split = it.value.dropLast(1).split(" ")
+        if(split.size !in listOf(2, 3))
+            return@replace it.value
+        if(split.size == 3)
+            return@replace "<documentationlink href=\"${split[1]}\">${split[2]}</documentationlink>"
+        else
+            return@replace "<documentationlink href=\"${split[1]}\">${split[1]}</documentationlink>"
+    }
+
+    override fun parseStringToDocNode(extractedString: String) = htmlToDocNode(extractedString)
+    override fun preparse(text: String) = replaceLinksWithHrefs(text)
+}
+
+
diff --git a/core/src/main/kotlin/parsers/MarkdownParser.kt b/core/src/main/kotlin/parsers/MarkdownParser.kt
new file mode 100644
index 00000000..44c917e3
--- /dev/null
+++ b/core/src/main/kotlin/parsers/MarkdownParser.kt
@@ -0,0 +1,206 @@
+package parsers
+
+import model.doc.*
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.intellij.markdown.ast.ASTNode
+import org.intellij.markdown.ast.impl.ListItemCompositeNode
+import org.intellij.markdown.flavours.commonmark.CommonMarkFlavourDescriptor
+import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.parsers.factories.DocNodesFromIElementFactory
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
+import org.jetbrains.kotlin.kdoc.parser.KDocKnownTag
+import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
+import org.intellij.markdown.parser.MarkdownParser as IntellijMarkdownParser
+
+class MarkdownParser (
+    private val resolutionFacade: DokkaResolutionFacade,
+    private val declarationDescriptor: DeclarationDescriptor
+    ) : Parser() {
+
+    inner class MarkdownVisitor(val text: String) {
+
+        private fun headersHandler(node: ASTNode): DocNode =
+            DocNodesFromIElementFactory.getInstance(node.type, visitNode(node.children.find { it.type == MarkdownTokenTypes.ATX_CONTENT }!!).children.drop(1))
+
+        private fun horizontalRulesHandler(node: ASTNode): DocNode =
+            DocNodesFromIElementFactory.getInstance(MarkdownTokenTypes.HORIZONTAL_RULE)
+
+        private fun emphasisHandler(node: ASTNode): DocNode =
+            DocNodesFromIElementFactory.getInstance(node.type, children = listOf(visitNode(node.children[node.children.size/2])))
+
+        private fun blockquotesHandler(node: ASTNode): DocNode =
+            DocNodesFromIElementFactory.getInstance(node.type, children = node.children.drop(1).map { visitNode(it) })
+
+        private fun listsHandler(node: ASTNode): DocNode {
+
+            val children = node.children.filterIsInstance<ListItemCompositeNode>().flatMap {
+                if( it.children.last().type in listOf(MarkdownElementTypes.ORDERED_LIST, MarkdownElementTypes.UNORDERED_LIST) ) {
+                    val nestedList = it.children.last()
+                    (it.children as MutableList).removeAt(it.children.lastIndex)
+                    listOf(it, nestedList)
+                }
+                else
+                    listOf(it)
+            }
+
+            return DocNodesFromIElementFactory.getInstance(
+                node.type,
+                children =
+                children
+                    .map {
+                        if(it.type == MarkdownElementTypes.LIST_ITEM)
+                            DocNodesFromIElementFactory.getInstance(
+                                it.type,
+                                children = it
+                                    .children
+                                    .drop(1)
+                                    .filter { it.type !in listOf(MarkdownTokenTypes.WHITE_SPACE, MarkdownTokenTypes.EOL) }
+                                    .map { visitNode(it) }
+                            )
+                        else
+                            visitNode(it)
+                    },
+                params =
+                if (node.type == MarkdownElementTypes.ORDERED_LIST) {
+                    val listNumberNode = node.children.first().children.first()
+                    mapOf("start" to text.substring(listNumberNode.startOffset, listNumberNode.endOffset).dropLast(2))
+                } else
+                    emptyMap()
+            )
+        }
+
+        private fun linksHandler(node: ASTNode): DocNode {
+            val linkNode = node.children.find { it.type == MarkdownElementTypes.LINK_LABEL }!!
+            val link = text.substring(linkNode.startOffset+1, linkNode.endOffset-1)
+
+            val dri: DRI? = if (link.startsWith("http") || link.startsWith("www")) {
+                null
+            } else {
+                DRI.from(
+                        resolveKDocLink(
+                        resolutionFacade.resolveSession.bindingContext,
+                        resolutionFacade,
+                        declarationDescriptor,
+                        null,
+                        link.split('.')
+                    ).single()
+                )
+            }
+            val href = mapOf("href" to link)
+            return when (node.type) {
+                MarkdownElementTypes.FULL_REFERENCE_LINK -> DocNodesFromIElementFactory.getInstance(node.type, params = href, children = node.children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!.children.drop(1).dropLast(1).map { visitNode(it) }, dri = dri)
+                else                                     -> DocNodesFromIElementFactory.getInstance(node.type, params = href, children = listOf(visitNode(linkNode)), dri = dri)
+            }
+        }
+
+        private fun imagesHandler(node: ASTNode): DocNode {
+            val linkNode = node.children.last().children.find { it.type == MarkdownElementTypes.LINK_LABEL }!!.children[1]
+            val link = text.substring(linkNode.startOffset, linkNode.endOffset)
+            val src = mapOf("src" to link)
+            return DocNodesFromIElementFactory.getInstance(node.type, params = src, children = listOf(visitNode(node.children.last().children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!)))
+        }
+
+        private fun codeSpansHandler(node: ASTNode): DocNode =
+            DocNodesFromIElementFactory.getInstance(
+                node.type,
+                children = listOf(
+                    DocNodesFromIElementFactory.getInstance(
+                        MarkdownTokenTypes.TEXT,
+                        body = text.substring(node.startOffset+1, node.endOffset-1).replace('\n', ' ').trimIndent()
+                    )
+
+                )
+            )
+
+        private fun codeFencesHandler(node: ASTNode): DocNode =
+            DocNodesFromIElementFactory.getInstance(
+                node.type,
+                children = node
+                    .children
+                    .filter { it.type == MarkdownTokenTypes.CODE_FENCE_CONTENT }
+                    .map { visitNode(it) },
+                params = node
+                    .children
+                    .find { it.type == MarkdownTokenTypes.FENCE_LANG }
+                    ?.let { mapOf("lang" to text.substring(it.startOffset, it.endOffset)) }
+                        ?: emptyMap()
+            )
+
+        private fun codeBlocksHandler(node: ASTNode): DocNode =
+            DocNodesFromIElementFactory.getInstance(node.type, children = node.children.map { visitNode(it) })
+
+        private fun defaultHandler(node: ASTNode): DocNode =
+            DocNodesFromIElementFactory.getInstance(MarkdownElementTypes.PARAGRAPH, children = node.children.map { visitNode(it) })
+
+        fun visitNode(node: ASTNode): DocNode =
+            when (node.type) {
+                MarkdownElementTypes.ATX_1,
+                MarkdownElementTypes.ATX_2,
+                MarkdownElementTypes.ATX_3,
+                MarkdownElementTypes.ATX_4,
+                MarkdownElementTypes.ATX_5,
+                MarkdownElementTypes.ATX_6                  -> headersHandler(node)
+                MarkdownTokenTypes.HORIZONTAL_RULE          -> horizontalRulesHandler(node)
+                MarkdownElementTypes.STRONG,
+                MarkdownElementTypes.EMPH                   -> emphasisHandler(node)
+                MarkdownElementTypes.FULL_REFERENCE_LINK,
+                MarkdownElementTypes.SHORT_REFERENCE_LINK   -> linksHandler(node)
+                MarkdownElementTypes.BLOCK_QUOTE            -> blockquotesHandler(node)
+                MarkdownElementTypes.UNORDERED_LIST,
+                MarkdownElementTypes.ORDERED_LIST           -> listsHandler(node)
+                MarkdownElementTypes.CODE_BLOCK             -> codeBlocksHandler(node)
+                MarkdownElementTypes.CODE_FENCE             -> codeFencesHandler(node)
+                MarkdownElementTypes.CODE_SPAN              -> codeSpansHandler(node)
+                MarkdownElementTypes.IMAGE                  -> imagesHandler(node)
+                MarkdownTokenTypes.EOL                      -> DocNodesFromIElementFactory.getInstance(MarkdownTokenTypes.TEXT, body = "\n")
+                MarkdownTokenTypes.WHITE_SPACE              -> DocNodesFromIElementFactory.getInstance(MarkdownTokenTypes.TEXT, body = " ")
+                MarkdownTokenTypes.CODE_FENCE_CONTENT,
+                MarkdownTokenTypes.CODE_LINE,
+                MarkdownTokenTypes.TEXT                     -> DocNodesFromIElementFactory.getInstance(MarkdownTokenTypes.TEXT, body = text.substring(node.startOffset, node.endOffset))
+                else                                        -> defaultHandler(node)
+            }
+    }
+
+    private fun markdownToDocNode(text: String): DocNode {
+
+        val flavourDescriptor = CommonMarkFlavourDescriptor()
+        val markdownAstRoot: ASTNode = IntellijMarkdownParser(flavourDescriptor).buildMarkdownTreeFromString(text)
+
+        return MarkdownVisitor(text).visitNode(markdownAstRoot)
+    }
+
+    override fun parseStringToDocNode(extractedString: String) = markdownToDocNode(extractedString)
+    override fun preparse(text: String) = text
+
+    fun parseFromKDocTag(kDocTag: KDocTag?): DocumentationNode {
+        return if(kDocTag == null)
+            DocumentationNode(emptyList())
+        else
+            DocumentationNode(
+                (listOf(kDocTag) + kDocTag.children).filterIsInstance<KDocTag>().map {
+                    when( it.knownTag ) {
+                        null                        -> Description(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.AUTHOR         -> Author(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.THROWS         -> Throws(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.EXCEPTION      -> Throws(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.PARAM          -> Param(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.RECEIVER       -> Receiver(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.RETURN         -> Return(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.SEE            -> See(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.SINCE          -> Since(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.CONSTRUCTOR    -> Constructor(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.PROPERTY       -> Property(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.SAMPLE         -> Sample(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.SUPPRESS       -> Suppress(parseStringToDocNode(it.getContent()))
+                    }
+                }
+            )
+    }
+
+
+
+
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/Parser.kt b/core/src/main/kotlin/parsers/Parser.kt
new file mode 100644
index 00000000..a2a90dcd
--- /dev/null
+++ b/core/src/main/kotlin/parsers/Parser.kt
@@ -0,0 +1,44 @@
+package parsers
+
+import model.doc.*
+import model.doc.Deprecated
+
+
+abstract class Parser {
+
+    abstract fun parseStringToDocNode(extractedString: String): DocNode
+    abstract fun preparse(text: String): String
+
+    fun parse(text: String): DocumentationNode {
+
+        val list = jkdocToListOfPairs(preparse(text))
+
+        val mappedList: List<DocType> = list.map {
+            when(it.first) {
+                "description"         -> Description(parseStringToDocNode(it.second))
+                "author"              -> Author(parseStringToDocNode(it.second))
+                "version"             -> Version(parseStringToDocNode(it.second))
+                "since"               -> Since(parseStringToDocNode(it.second))
+                "see"                 -> See(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "param"               -> Param(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "property"            -> Property(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "return"              -> Return(parseStringToDocNode(it.second))
+                "constructor"         -> Constructor(parseStringToDocNode(it.second))
+                "receiver"            -> Receiver(parseStringToDocNode(it.second))
+                "throws", "exception" -> Throws(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "deprecated"          -> Deprecated(parseStringToDocNode(it.second))
+                "sample"              -> Sample(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "suppress"            -> Suppress(parseStringToDocNode(it.second))
+                else                  -> CustomTag(parseStringToDocNode(it.second), it.first)
+            }
+        }
+        return DocumentationNode(mappedList)
+    }
+
+    private fun jkdocToListOfPairs(javadoc: String): List<Pair<String, String>> =
+        "description $javadoc"
+            .split("\n@")
+            .map {
+                it.substringBefore(' ') to it.substringAfter(' ')
+            }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/factories/DocNodesFromIElementFactory.kt b/core/src/main/kotlin/parsers/factories/DocNodesFromIElementFactory.kt
new file mode 100644
index 00000000..a93be0d3
--- /dev/null
+++ b/core/src/main/kotlin/parsers/factories/DocNodesFromIElementFactory.kt
@@ -0,0 +1,36 @@
+package org.jetbrains.dokka.parsers.factories
+
+import model.doc.*
+import org.intellij.markdown.IElementType
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.jetbrains.dokka.links.DRI
+import java.lang.NullPointerException
+
+object DocNodesFromIElementFactory {
+    fun getInstance(type: IElementType, children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
+        when(type) {
+            MarkdownElementTypes.SHORT_REFERENCE_LINK,
+            MarkdownElementTypes.FULL_REFERENCE_LINK    -> if(dri == null) A(children, params) else DocumentationLink(children, params, dri)
+            MarkdownElementTypes.STRONG                 -> B(children, params)
+            MarkdownElementTypes.BLOCK_QUOTE            -> BlockQuote(children, params)
+            MarkdownElementTypes.CODE_SPAN,
+            MarkdownElementTypes.CODE_BLOCK,
+            MarkdownElementTypes.CODE_FENCE             -> Code(children, params)
+            MarkdownElementTypes.ATX_1                  -> H1(children, params)
+            MarkdownElementTypes.ATX_2                  -> H2(children, params)
+            MarkdownElementTypes.ATX_3                  -> H3(children, params)
+            MarkdownElementTypes.ATX_4                  -> H4(children, params)
+            MarkdownElementTypes.ATX_5                  -> H5(children, params)
+            MarkdownElementTypes.ATX_6                  -> H6(children, params)
+            MarkdownElementTypes.EMPH                   -> I(children, params)
+            MarkdownElementTypes.IMAGE                  -> Img(children, params)
+            MarkdownElementTypes.LIST_ITEM              -> Li(children, params)
+            MarkdownElementTypes.ORDERED_LIST           -> Ol(children, params)
+            MarkdownElementTypes.UNORDERED_LIST         -> Ul(children, params)
+            MarkdownElementTypes.PARAGRAPH              -> P(children, params)
+            MarkdownTokenTypes.TEXT                     -> Text(children, params, body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"))
+            MarkdownTokenTypes.HORIZONTAL_RULE          -> HorizontalRule()
+            else                                        -> CustomNode(children, params)
+        }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/factories/DocNodesFromStringFactory.kt b/core/src/main/kotlin/parsers/factories/DocNodesFromStringFactory.kt
new file mode 100644
index 00000000..49102ed0
--- /dev/null
+++ b/core/src/main/kotlin/parsers/factories/DocNodesFromStringFactory.kt
@@ -0,0 +1,76 @@
+package org.jetbrains.dokka.parsers.factories
+
+import model.doc.*
+import org.jetbrains.dokka.links.DRI
+import java.lang.NullPointerException
+
+object DocNodesFromStringFactory {
+    fun getInstance(name: String, children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
+        when(name) {
+            "a" -> A(children, params)
+            "big" -> Big(children, params)
+            "b" -> B(children, params)
+            "blockquote" -> BlockQuote(children, params)
+            "bite" -> Cite(children, params)
+            "bode" -> Code(children, params)
+            "dd" -> Dd(children, params)
+            "dfn" -> Dfn(children, params)
+            "dir" -> Dir(children, params)
+            "div" -> Div(children, params)
+            "dl" -> Dl(children, params)
+            "dt" -> Dt(children, params)
+            "Em" -> Em(children, params)
+            "font" -> Font(children, params)
+            "footer" -> Footer(children, params)
+            "frame" -> Frame(children, params)
+            "frameset" -> FrameSet(children, params)
+            "h1" -> H1(children, params)
+            "h2" -> H2(children, params)
+            "h3" -> H3(children, params)
+            "h4" -> H4(children, params)
+            "h5" -> H5(children, params)
+            "h6" -> H6(children, params)
+            "head" -> Head(children, params)
+            "header" -> Header(children, params)
+            "html" -> Html(children, params)
+            "i" -> I(children, params)
+            "iframe" -> IFrame(children, params)
+            "img" -> Img(children, params)
+            "input" -> Input(children, params)
+            "li" -> Li(children, params)
+            "link" -> Link(children, params)
+            "listing" -> Listing(children, params)
+            "main" -> Main(children, params)
+            "menu" -> Menu(children, params)
+            "meta" -> Meta(children, params)
+            "nav" -> Nav(children, params)
+            "noframes" -> NoFrames(children, params)
+            "noscript" -> NoScript(children, params)
+            "ol" -> Ol(children, params)
+            "p" -> P(children, params)
+            "pre" -> Pre(children, params)
+            "script" -> Script(children, params)
+            "section" -> Section(children, params)
+            "small" -> Small(children, params)
+            "span" -> Span(children, params)
+            "strong" -> Strong(children, params)
+            "sub" -> Sub(children, params)
+            "sup" -> Sup(children, params)
+            "table" -> Table(children, params)
+            "#text" -> Text(children, params, body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"))
+            "tBody" -> TBody(children, params)
+            "td" -> Td(children, params)
+            "tFoot" -> TFoot(children, params)
+            "th" -> Th(children, params)
+            "tHead" -> THead(children, params)
+            "title" -> Title(children, params)
+            "tr" -> Tr(children, params)
+            "tt" -> Tt(children, params)
+            "u" -> U(children, params)
+            "ul" -> Ul(children, params)
+            "var" -> Var(children, params)
+            "documentationlink" -> DocumentationLink(children, params, dri ?: throw NullPointerException("DRI cannot be passed null while constructing documentation link!"))
+            "hr" -> HorizontalRule()
+            else -> CustomNode(children, params)
+        }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index d89fc031..e46ade01 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.pages.DefaultMarkdownToContentConverter
+import org.jetbrains.dokka.pages.DocNodeToContentConverter
 import org.jetbrains.dokka.renderers.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProvider
 import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
@@ -14,7 +14,7 @@ object DefaultExtensions : DokkaExtensionHandler {
         when (point) {
             CoreExtensions.descriptorToDocumentationTranslator -> DefaultDescriptorToDocumentationTranslator
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
-            CoreExtensions.markdownToContentConverterFactory -> ::DefaultMarkdownToContentConverter
+            CoreExtensions.markdownToContentConverterFactory -> ::DocNodeToContentConverter
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
             CoreExtensions.rendererFactory -> ::HtmlRenderer
             CoreExtensions.locationProviderFactory -> ::DefaultLocationProvider
diff --git a/core/src/main/kotlin/renderers/HtmlRenderer.kt b/core/src/main/kotlin/renderers/HtmlRenderer.kt
index c04a18b4..e9f2801e 100644
--- a/core/src/main/kotlin/renderers/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/HtmlRenderer.kt
@@ -20,7 +20,12 @@ open class HtmlRenderer(
     }
 
     protected open fun buildListItems(items: List<ContentNode>, pageContext: PageNode) =
-        "<li>\n${items.joinToString("\n</li>\n<li>\n") { it.build(pageContext) }}\n</li>"
+        items.joinToString("") {
+            if (it is ContentText) "<li>\n${it.build(pageContext)}\n</li>\n" else buildList(
+                it as ContentList,
+                pageContext
+            )
+        }
 
     override fun buildResource(node: ContentEmbeddedResource, pageContext: PageNode): String { // TODO: extension point there
         val imageExtensions = setOf("png", "jpg", "jpeg", "gif", "bmp", "tif", "webp", "svg")
@@ -59,7 +64,7 @@ open class HtmlRenderer(
 
     override fun buildLink(text: String, address: String): String = "<a href=\"$address\">$text</a>"
 
-    override fun buildCode(code: List<ContentNode>, language: String, pageContext: PageNode): String = "<code>$code</code>"
+    override fun buildCode(code: List<ContentNode>, language: String, pageContext: PageNode): String = buildNewLine() + "<code>${code.joinToString("") { (it as ContentText).text + buildNewLine() }}</code>"
 
     override fun buildText(textNode: ContentText): String = super.buildText(textNode).htmlEscape()
 
diff --git a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
index 4ffa4295..bdd345f1 100644
--- a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
+++ b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
@@ -12,15 +12,13 @@ import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
 import org.jetbrains.kotlin.idea.kdoc.findKDoc
-import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocLink
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.KotlinType
+import parsers.MarkdownParser
 
 object DefaultDescriptorToDocumentationTranslator: DescriptorToDocumentationTranslator {
     override fun invoke(
@@ -36,7 +34,7 @@ object DefaultDescriptorToDocumentationTranslator: DescriptorToDocumentationTran
 class DokkaDescriptorVisitor(
     private val platformData: PlatformData,
     private val resolutionFacade: DokkaResolutionFacade
-) : DeclarationDescriptorVisitorEmptyBodies<DocumentationNode, DRI>() {
+) : DeclarationDescriptorVisitorEmptyBodies<Documentable, DRI>() {
     override fun visitDeclarationDescriptor(descriptor: DeclarationDescriptor, parent: DRI): Nothing {
         throw IllegalStateException("${javaClass.simpleName} should never enter ${descriptor.javaClass.simpleName}")
     }
@@ -69,7 +67,7 @@ class DokkaDescriptorVisitor(
             scope.classes(dri),
             descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData(),
             listOfNotNull(descriptorData),
-            getXMLDRIs(descriptor, descriptorData).toMutableSet()
+            mutableSetOf() // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet()
         )
     }
 
@@ -147,39 +145,15 @@ class DokkaDescriptorVisitor(
 
     private fun DeclarationDescriptor.resolveDescriptorData(): PlatformInfo {
         val doc = findKDoc()
-        val links = doc?.children?.filter { it is KDocLink }?.flatMap { link ->
-            val destination = link.children.first { it is KDocName }.text
-            resolveKDocLink(
-                resolutionFacade.resolveSession.bindingContext,
-                resolutionFacade,
-                this,
-                null,
-                destination.split('.')
-            ).map { Pair(destination, DRI.from(it)) }
-        }?.toMap() ?: emptyMap()
-        return BasePlatformInfo(doc, links, listOf(platformData))
+        val parser: MarkdownParser = MarkdownParser(resolutionFacade, this)
+        val docHeader = parser.parseFromKDocTag(doc)
+        return BasePlatformInfo(docHeader, listOf(platformData))
     }
 
     private fun ClassDescriptor.resolveClassDescriptionData(): ClassPlatformInfo {
         return ClassPlatformInfo(resolveDescriptorData(),
             (getSuperInterfaces() + getAllSuperclassesWithoutAny()).map { DRI.from(it) })
     }
-
-    private fun getXMLDRIs(descriptor: DeclarationDescriptor, platformInfo: PlatformInfo?) =
-        platformInfo?.docTag?.children
-            ?.filter {
-                it.text.contains("@attr")
-            }?.flatMap { ref ->
-                val matchResult = "@attr\\s+ref\\s+(.+)".toRegex().matchEntire(ref.text)
-                val toFind = matchResult?.groups?.last()?.value.orEmpty()
-                resolveKDocLink(
-                    resolutionFacade.resolveSession.bindingContext,
-                    resolutionFacade,
-                    descriptor,
-                    null,
-                    toFind.split('.')
-                ).map { XMLMega("@attr ref", DRI.from(it)) }
-            }.orEmpty()
 }
 
 data class XMLMega(val key: String, val dri: DRI) : Extra
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
index 2b00c582..ef0f48d6 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
@@ -14,14 +14,13 @@ internal object DefaultDocumentationNodeMerger : DocumentationNodeMerger {
         )
 }
 
-private fun <T: DocumentationNode> merge(elements: List<T>, reducer: (T, T) -> T): List<T> =
+private fun <T: Documentable> merge(elements: List<T>, reducer: (T, T) -> T): List<T> =
     elements.groupingBy { it.dri }
         .reduce { _, left, right -> reducer(left, right)}
         .values.toList()
 
 fun PlatformInfo.mergeWith(other: PlatformInfo?) = BasePlatformInfo(
-    docTag,
-    links,
+    documentationNode,
     (platformData + (other?.platformData ?: emptyList())).distinct()
 )
 
@@ -31,12 +30,12 @@ fun ClassPlatformInfo.mergeWith(other: ClassPlatformInfo?) = ClassPlatformInfo(
 )
 
 fun List<ClassPlatformInfo>.mergeClassPlatformInfo() : List<ClassPlatformInfo> =
-    groupingBy { it.docTag.toString() + it.links + it.inherited}.reduce {
+    groupingBy { it.documentationNode.children + it.inherited}.reduce {
             _, left, right -> left.mergeWith(right)
     }.values.toList()
 
 fun List<PlatformInfo>.merge() : List<PlatformInfo> =
-    groupingBy { it.docTag.toString() + it.links }.reduce {
+    groupingBy { it.documentationNode }.reduce {
         _, left, right -> left.mergeWith(right)
     }.values.toList()
 
diff --git a/core/src/main/kotlin/utilities/nodeDebug.kt b/core/src/main/kotlin/utilities/nodeDebug.kt
index 3290202e..984f13ed 100644
--- a/core/src/main/kotlin/utilities/nodeDebug.kt
+++ b/core/src/main/kotlin/utilities/nodeDebug.kt
@@ -1,13 +1,13 @@
 package org.jetbrains.dokka.utilities
 
-import org.jetbrains.dokka.model.DocumentationNode
+import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.pages.*
 
 const val DOWN = '\u2503'
 const val BRANCH = '\u2523'
 const val LAST = '\u2517'
 
-fun DocumentationNode.pretty(prefix: String = "", isLast: Boolean = true): String {
+fun Documentable.pretty(prefix: String = "", isLast: Boolean = true): String {
     val nextPrefix = prefix + (if (isLast) ' ' else DOWN) + ' '
 
     return prefix + (if (isLast) LAST else BRANCH) + this.toString() +
diff --git a/core/src/test/kotlin/markdown/ParserTest.kt b/core/src/test/kotlin/markdown/ParserTest.kt
index b0ec68ff..e5944e17 100644
--- a/core/src/test/kotlin/markdown/ParserTest.kt
+++ b/core/src/test/kotlin/markdown/ParserTest.kt
@@ -1,17 +1,17 @@
 package org.jetbrains.dokka.tests
 
 import org.junit.Test
-import org.jetbrains.dokka.toTestString
-import org.jetbrains.dokka.parseMarkdown
+//import org.jetbrains.dokkatoTestString
+//import org.jetbrains.dokka.parseMarkdown
 import org.junit.Ignore
 
 @Ignore public class ParserTest {
     fun runTestFor(text : String) {
         println("MD: ---")
         println(text)
-        val markdownTree = parseMarkdown(text)
+//        val markdownTree = parseMarkdown(text)
         println("AST: ---")
-        println(markdownTree.toTestString())
+//        println(markdownTree.toTestString())
         println()
     }
 
diff --git a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
index 0c8bd654..ff3e83a3 100644
--- a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
+++ b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
@@ -28,7 +28,7 @@ object MathjaxTransformer : PageNodeTransformer {
 
 
     private val PageNode.isNeedingMathjax
-        get() = documentationNode?.platformInfo
+        get() = documentable?.platformInfo
             ?.flatMap { it.docTag?.children?.toList().orEmpty() }
             .orEmpty()
             .any { it.text == ANNOTATION }
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index 64d52b82..961a6387 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.xml
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.model.DocumentationNode
+import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.model.dfs
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -26,12 +26,12 @@ object XmlTransformer : PageNodeTransformer {
             if (node !is ClassPageNode) node
             else {
                 val refs =
-                    node.documentationNode?.extra?.filterIsInstance<XMLMega>()?.filter { it.key == "@attr ref" }
+                    node.documentable?.extra?.filterIsInstance<XMLMega>()?.filter { it.key == "@attr ref" }
                         .orEmpty()
-                val elementsToAdd = mutableListOf<DocumentationNode>()
+                val elementsToAdd = mutableListOf<Documentable>()
 
                 refs.forEach { ref ->
-                    input.documentationNode?.dfs { it.dri == ref.dri }?.let { elementsToAdd.add(it) }
+                    input.documentable?.dfs { it.dri == ref.dri }?.let { elementsToAdd.add(it) }
                 }
                 val platformData = node.platforms().toSet()
                 val refTable = DefaultPageContentBuilder.group(
-- 
cgit 


From 288431f21b18f5311de77c9afcb29346cb7c6498 Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Fri, 13 Dec 2019 16:24:16 +0100
Subject: Changes naming and applies pull request's requirements

---
 core/src/main/kotlin/CoreExtensions.kt             |  4 +-
 core/src/main/kotlin/model/Documentable.kt         | 23 +++---
 core/src/main/kotlin/model/doc/DocNode.kt          | 74 ------------------
 core/src/main/kotlin/model/doc/DocTag.kt           | 81 +++++++++++++++++++
 core/src/main/kotlin/model/doc/DocType.kt          | 18 -----
 .../src/main/kotlin/model/doc/DocumentationNode.kt |  4 +-
 core/src/main/kotlin/model/doc/TagWrapper.kt       | 18 +++++
 .../kotlin/pages/CommentsToContentConverter.kt     | 13 ++++
 .../main/kotlin/pages/DocNodeToContentConverter.kt | 82 -------------------
 .../main/kotlin/pages/DocTagToContentConverter.kt  | 79 +++++++++++++++++++
 .../kotlin/pages/MarkdownToContentConverter.kt     | 15 ----
 core/src/main/kotlin/pages/PageBuilder.kt          | 14 ++--
 core/src/main/kotlin/pages/PageContentBuilder.kt   | 18 ++---
 core/src/main/kotlin/parsers/HtmlParser.kt         | 10 +--
 core/src/main/kotlin/parsers/MarkdownParser.kt     | 91 ++++++++++++----------
 core/src/main/kotlin/parsers/Parser.kt             | 12 +--
 .../factories/DocNodesFromIElementFactory.kt       |  6 +-
 .../parsers/factories/DocNodesFromStringFactory.kt |  6 +-
 .../main/kotlin/plugability/DefaultExtensions.kt   |  4 +-
 .../DefaultDescriptorToDocumentationTranslator.kt  |  2 +-
 .../DefaultDocumentationToPageTranslator.kt        |  2 +-
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt   | 11 +--
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |  4 +-
 23 files changed, 302 insertions(+), 289 deletions(-)
 delete mode 100644 core/src/main/kotlin/model/doc/DocNode.kt
 create mode 100644 core/src/main/kotlin/model/doc/DocTag.kt
 delete mode 100644 core/src/main/kotlin/model/doc/DocType.kt
 create mode 100644 core/src/main/kotlin/model/doc/TagWrapper.kt
 create mode 100644 core/src/main/kotlin/pages/CommentsToContentConverter.kt
 delete mode 100644 core/src/main/kotlin/pages/DocNodeToContentConverter.kt
 create mode 100644 core/src/main/kotlin/pages/DocTagToContentConverter.kt
 delete mode 100644 core/src/main/kotlin/pages/MarkdownToContentConverter.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 87509dc4..7393dd68 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.pages.MarkdownToContentConverter
+import org.jetbrains.dokka.pages.CommentsToContentConverter
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.ExtensionPoint
@@ -23,7 +23,7 @@ object CoreExtensions {
     val descriptorToDocumentationTranslator by coreExtension<DescriptorToDocumentationTranslator>()
     val documentationMerger by coreExtension<DocumentationNodeMerger>()
     val documentationTransformer by coreExtension<DocumentationNodeTransformer>()
-    val markdownToContentConverterFactory by coreExtension<(DokkaContext) -> MarkdownToContentConverter>()
+    val commentsToContentConverterFactory by coreExtension<(DokkaContext) -> CommentsToContentConverter>()
     val documentationToPageTranslator by coreExtension<DocumentationToPageTranslator>()
     val pageTransformer by coreExtension<PageNodeTransformer>()
     val rendererFactory by coreExtension<(FileWriter, LocationProvider, DokkaContext) -> Renderer>()
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index 9f676a1e..4bdd41ae 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.model
 
-import model.doc.*
+import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.PlatformData
@@ -106,7 +106,7 @@ abstract class Documentable {
     abstract val children: List<Documentable>
 
     override fun toString(): String {
-        return "${javaClass.simpleName}($dri)" + briefDocstring.takeIf { it.isNotBlank() }?.let { " [$it]" }.orEmpty()
+        return "${javaClass.simpleName}($dri)" + briefDocTagString.takeIf { it.isNotBlank() }?.let { " [$it]" }.orEmpty()
     }
 
     override fun equals(other: Any?) = other is Documentable && this.dri == other.dri
@@ -118,15 +118,16 @@ abstract class Documentable {
     val commentsData: List<DocumentationNode>
         get() = platformInfo.map { it.documentationNode }
 
-    val briefDocstring: String
-        get() = docNodeSummary(platformInfo.firstOrNull()?.documentationNode?.children?.firstOrNull()?.root ?: Text(body = "")).shorten(40)
-
-    private fun docNodeSummary(docNode: DocNode): String {
-        if(docNode.children.isEmpty() && docNode is Text)
-            return docNode.body
-
-        return docNode.children.joinToString(" ") { docNodeSummary(it) }
-    }
+    val briefDocTagString: String
+        get() =
+            platformInfo
+            .firstOrNull()
+            ?.documentationNode
+            ?.children
+            ?.firstOrNull()
+            ?.root
+            ?.docTagSummary()
+            ?.shorten(40) ?: ""
 
     open val extra: MutableSet<Extra> = mutableSetOf()
 }
diff --git a/core/src/main/kotlin/model/doc/DocNode.kt b/core/src/main/kotlin/model/doc/DocNode.kt
deleted file mode 100644
index 0c643551..00000000
--- a/core/src/main/kotlin/model/doc/DocNode.kt
+++ /dev/null
@@ -1,74 +0,0 @@
-package model.doc
-
-import org.jetbrains.dokka.links.DRI
-
-sealed class DocNode(
-    val children: List<DocNode>,
-    val params: Map<String, String>
-)
-
-class A(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
-class Big(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class B(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
-class BlockQuote(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())       : DocNode(children, params)
-class Cite(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Code(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Dd(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class Dfn(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class Dir(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class Div(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class Dl(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class Dt(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class Em(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class Font(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Footer(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
-class Frame(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
-class FrameSet(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())         : DocNode(children, params)
-class H1(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class H2(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class H3(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class H4(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class H5(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class H6(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class Head(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Header(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
-class Html(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class I(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
-class IFrame(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
-class Img(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class Input(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
-class Li(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class Link(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Listing(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())          : DocNode(children, params)
-class Main(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Menu(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Meta(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Nav(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class NoFrames(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())         : DocNode(children, params)
-class NoScript(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())         : DocNode(children, params)
-class Ol(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class P(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
-class Pre(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class Script(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
-class Section(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())          : DocNode(children, params)
-class Small(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
-class Span(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())             : DocNode(children, params)
-class Strong(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())           : DocNode(children, params)
-class Sub(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class Sup(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class Table(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
-class Text(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap(), val body: String = "") : DocNode(children, params)
-class TBody(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
-class Td(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class TFoot(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
-class Th(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class THead(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
-class Title(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())            : DocNode(children, params)
-class Tr(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class Tt(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class U(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())                : DocNode(children, params)
-class Ul(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())               : DocNode(children, params)
-class Var(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())              : DocNode(children, params)
-class DocumentationLink(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap(), val dri: DRI) : DocNode(children, params)
-class HorizontalRule()                                                                                  : DocNode(emptyList(), emptyMap())
-class CustomNode(children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap())       : DocNode(children, params)
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/doc/DocTag.kt b/core/src/main/kotlin/model/doc/DocTag.kt
new file mode 100644
index 00000000..6d5850a0
--- /dev/null
+++ b/core/src/main/kotlin/model/doc/DocTag.kt
@@ -0,0 +1,81 @@
+package org.jetbrains.dokka.model.doc
+
+import org.jetbrains.dokka.links.DRI
+
+sealed class DocTag(
+    val children: List<DocTag>,
+    val params: Map<String, String>
+) {
+    fun docTagSummary(): String {
+        if(this.children.isEmpty() && this is Text)
+            return this.body
+
+        return this.children.joinToString(" ") { it.docTagSummary() }
+    }
+}
+
+class A(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())                : DocTag(children, params)
+class Big(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class B(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())                : DocTag(children, params)
+class BlockQuote(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())       : DocTag(children, params)
+class Cite(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Code(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Dd(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class Dfn(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class Dir(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class Div(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class Dl(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class Dt(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class Em(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class Font(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Footer(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())           : DocTag(children, params)
+class Frame(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())            : DocTag(children, params)
+class FrameSet(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())         : DocTag(children, params)
+class H1(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class H2(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class H3(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class H4(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class H5(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class H6(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class Head(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Header(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())           : DocTag(children, params)
+class Html(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class I(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())                : DocTag(children, params)
+class IFrame(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())           : DocTag(children, params)
+class Img(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class Input(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())            : DocTag(children, params)
+class Li(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class Link(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Listing(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())          : DocTag(children, params)
+class Main(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Menu(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Meta(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Nav(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class NoFrames(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())         : DocTag(children, params)
+class NoScript(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())         : DocTag(children, params)
+class Ol(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class P(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())                : DocTag(children, params)
+class Pre(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class Script(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())           : DocTag(children, params)
+class Section(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())          : DocTag(children, params)
+class Small(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())            : DocTag(children, params)
+class Span(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())             : DocTag(children, params)
+class Strong(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())           : DocTag(children, params)
+class Sub(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class Sup(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class Table(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())            : DocTag(children, params)
+class Text(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), val body: String = "") : DocTag(children, params)
+class TBody(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())            : DocTag(children, params)
+class Td(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class TFoot(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())            : DocTag(children, params)
+class Th(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class THead(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())            : DocTag(children, params)
+class Title(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())            : DocTag(children, params)
+class Tr(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class Tt(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class U(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())                : DocTag(children, params)
+class Ul(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())               : DocTag(children, params)
+class Var(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())              : DocTag(children, params)
+class DocumentationLink(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), val dri: DRI) : DocTag(children, params)
+class HorizontalRule                                                                                   : DocTag(emptyList(), emptyMap())
+class CustomDocTag(children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap())     : DocTag(children, params)
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/doc/DocType.kt b/core/src/main/kotlin/model/doc/DocType.kt
deleted file mode 100644
index 0888876e..00000000
--- a/core/src/main/kotlin/model/doc/DocType.kt
+++ /dev/null
@@ -1,18 +0,0 @@
-package model.doc
-
-sealed class DocType(val root: DocNode)
-class Description(root: DocNode) : DocType(root)
-class Author(root: DocNode) : DocType(root)
-class Version(root: DocNode) : DocType(root)
-class Since(root: DocNode) : DocType(root)
-class See(root: DocNode, val name: String) : DocType(root)
-class Param(root: DocNode, val name: String) : DocType(root)
-class Return(root: DocNode) : DocType(root)
-class Receiver(root: DocNode) : DocType(root)
-class Constructor(root: DocNode) : DocType(root)
-class Throws(root: DocNode, val name: String) : DocType(root)
-class Sample(root: DocNode, val name: String) : DocType(root)
-class Deprecated(root: DocNode) : DocType(root)
-class Property(root: DocNode, val name: String) : DocType(root)
-class Suppress(root: DocNode) : DocType(root)
-class CustomTag(root: DocNode, val name: String) : DocType(root)
diff --git a/core/src/main/kotlin/model/doc/DocumentationNode.kt b/core/src/main/kotlin/model/doc/DocumentationNode.kt
index 73424616..a143a941 100644
--- a/core/src/main/kotlin/model/doc/DocumentationNode.kt
+++ b/core/src/main/kotlin/model/doc/DocumentationNode.kt
@@ -1,3 +1,3 @@
-package model.doc
+package org.jetbrains.dokka.model.doc
 
-data class DocumentationNode(val children: List<DocType>)
\ No newline at end of file
+data class DocumentationNode(val children: List<TagWrapper>)
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/doc/TagWrapper.kt b/core/src/main/kotlin/model/doc/TagWrapper.kt
new file mode 100644
index 00000000..8def013e
--- /dev/null
+++ b/core/src/main/kotlin/model/doc/TagWrapper.kt
@@ -0,0 +1,18 @@
+package org.jetbrains.dokka.model.doc
+
+sealed class TagWrapper(val root: DocTag)
+class Description(root: DocTag) : TagWrapper(root)
+class Author(root: DocTag) : TagWrapper(root)
+class Version(root: DocTag) : TagWrapper(root)
+class Since(root: DocTag) : TagWrapper(root)
+class See(root: DocTag, val name: String) : TagWrapper(root)
+class Param(root: DocTag, val name: String) : TagWrapper(root)
+class Return(root: DocTag) : TagWrapper(root)
+class Receiver(root: DocTag) : TagWrapper(root)
+class Constructor(root: DocTag) : TagWrapper(root)
+class Throws(root: DocTag, val name: String) : TagWrapper(root)
+class Sample(root: DocTag, val name: String) : TagWrapper(root)
+class Deprecated(root: DocTag) : TagWrapper(root)
+class Property(root: DocTag, val name: String) : TagWrapper(root)
+class Suppress(root: DocTag) : TagWrapper(root)
+class CustomWrapperTag(root: DocTag, val name: String) : TagWrapper(root)
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/CommentsToContentConverter.kt b/core/src/main/kotlin/pages/CommentsToContentConverter.kt
new file mode 100644
index 00000000..78c7ff4c
--- /dev/null
+++ b/core/src/main/kotlin/pages/CommentsToContentConverter.kt
@@ -0,0 +1,13 @@
+package org.jetbrains.dokka.pages
+
+import org.jetbrains.dokka.model.doc.DocTag
+
+interface CommentsToContentConverter {
+    fun buildContent(
+        docTag: DocTag,
+        dci: DCI,
+        platforms: Set<PlatformData>,
+        styles: Set<Style> = emptySet(),
+        extras: Set<Extra> = emptySet()
+    ): List<ContentNode>
+}
diff --git a/core/src/main/kotlin/pages/DocNodeToContentConverter.kt b/core/src/main/kotlin/pages/DocNodeToContentConverter.kt
deleted file mode 100644
index dce69114..00000000
--- a/core/src/main/kotlin/pages/DocNodeToContentConverter.kt
+++ /dev/null
@@ -1,82 +0,0 @@
-package org.jetbrains.dokka.pages
-
-import model.doc.*
-import org.intellij.markdown.MarkdownElementTypes
-import org.intellij.markdown.MarkdownTokenTypes
-import org.jetbrains.dokka.markdown.MarkdownNode
-import org.jetbrains.dokka.plugability.DokkaContext
-
-class DocNodeToContentConverter(
-    private val context: DokkaContext
-) : MarkdownToContentConverter {
-    override fun buildContent(
-        docNode: DocNode,
-        dci: DCI,
-        platforms: Set<PlatformData>,
-        styles: Set<Style>,
-        extras: Set<Extra>
-
-    ): List<ContentNode> {
-
-        fun buildChildren(docNode: DocNode, newStyles: Set<Style> = emptySet(), newExtras: Set<Extra> = emptySet()) =
-            docNode.children.flatMap {
-                buildContent(it, dci, platforms, styles + newStyles, extras + newExtras)
-            }
-
-        fun buildHeader(level: Int) =
-            listOf(ContentHeader(buildChildren(docNode), level, dci, platforms, styles, extras))
-
-        fun buildList(ordered: Boolean) =
-            listOf(ContentList(buildChildren(docNode), ordered, dci, platforms, styles, extras))
-
-        return when (docNode) {
-            is H1 -> buildHeader(1)
-            is H2 -> buildHeader(2)
-            is H3 -> buildHeader(3)
-            is H4 -> buildHeader(4)
-            is H5 -> buildHeader(5)
-            is H6 -> buildHeader(6)
-            is Ul -> buildList(false)
-            is Ol -> buildList(true)
-            is Li -> buildChildren(docNode)
-            is B -> buildChildren(docNode, setOf(TextStyle.Strong))
-            is I -> buildChildren(docNode, setOf(TextStyle.Italic))
-            is P -> buildChildren(docNode, newStyles = setOf(TextStyle.Paragraph))
-            is A -> listOf(
-                ContentResolvedLink(
-                    buildChildren(docNode),
-                    docNode.params.get("href")!!,
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            is DocumentationLink -> listOf(
-                ContentDRILink(
-                    buildChildren(docNode),
-                    docNode.dri,
-                    DCI(docNode.dri, ContentKind.Symbol),
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            is BlockQuote -> throw NotImplementedError("Implement DocNotToContent BlockQuote!")
-            is Code -> listOf(
-                ContentCode(
-                    buildChildren(docNode),
-                    "",
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            is Img -> throw NotImplementedError("Implement DocNotToContent Img!")
-            is HorizontalRule -> listOf(ContentText("", dci, platforms, setOf()))
-            is Text -> listOf(ContentText(docNode.body, dci, platforms, styles, extras))
-            else -> buildChildren(docNode)
-        }
-    }
-}
diff --git a/core/src/main/kotlin/pages/DocTagToContentConverter.kt b/core/src/main/kotlin/pages/DocTagToContentConverter.kt
new file mode 100644
index 00000000..da19765e
--- /dev/null
+++ b/core/src/main/kotlin/pages/DocTagToContentConverter.kt
@@ -0,0 +1,79 @@
+package org.jetbrains.dokka.pages
+
+import org.jetbrains.dokka.model.doc.*
+import org.jetbrains.dokka.plugability.DokkaContext
+
+class DocTagToContentConverter(
+    private val context: DokkaContext
+) : CommentsToContentConverter {
+    override fun buildContent(
+        docTag: DocTag,
+        dci: DCI,
+        platforms: Set<PlatformData>,
+        styles: Set<Style>,
+        extras: Set<Extra>
+
+    ): List<ContentNode> {
+
+        fun buildChildren(docTag: DocTag, newStyles: Set<Style> = emptySet(), newExtras: Set<Extra> = emptySet()) =
+            docTag.children.flatMap {
+                buildContent(it, dci, platforms, styles + newStyles, extras + newExtras)
+            }
+
+        fun buildHeader(level: Int) =
+            listOf(ContentHeader(buildChildren(docTag), level, dci, platforms, styles, extras))
+
+        fun buildList(ordered: Boolean) =
+            listOf(ContentList(buildChildren(docTag), ordered, dci, platforms, styles, extras))
+
+        return when (docTag) {
+            is H1 -> buildHeader(1)
+            is H2 -> buildHeader(2)
+            is H3 -> buildHeader(3)
+            is H4 -> buildHeader(4)
+            is H5 -> buildHeader(5)
+            is H6 -> buildHeader(6)
+            is Ul -> buildList(false)
+            is Ol -> buildList(true)
+            is Li -> buildChildren(docTag)
+            is B -> buildChildren(docTag, setOf(TextStyle.Strong))
+            is I -> buildChildren(docTag, setOf(TextStyle.Italic))
+            is P -> buildChildren(docTag, newStyles = setOf(TextStyle.Paragraph))
+            is A -> listOf(
+                ContentResolvedLink(
+                    buildChildren(docTag),
+                    docTag.params.get("href")!!,
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is DocumentationLink -> listOf(
+                ContentDRILink(
+                    buildChildren(docTag),
+                    docTag.dri,
+                    DCI(docTag.dri, ContentKind.Symbol),
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is BlockQuote -> TODO("Implement DocNotToContent BlockQuote!")
+            is Code -> listOf(
+                ContentCode(
+                    buildChildren(docTag),
+                    "",
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is Img -> TODO("Implement DocNotToContent Img!")
+            is HorizontalRule -> listOf(ContentText("", dci, platforms, setOf()))
+            is Text -> listOf(ContentText(docTag.body, dci, platforms, styles, extras))
+            else -> buildChildren(docTag)
+        }
+    }
+}
diff --git a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt b/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
deleted file mode 100644
index 321a3f02..00000000
--- a/core/src/main/kotlin/pages/MarkdownToContentConverter.kt
+++ /dev/null
@@ -1,15 +0,0 @@
-package org.jetbrains.dokka.pages
-
-import model.doc.DocNode
-import org.jetbrains.dokka.markdown.MarkdownNode
-import org.jetbrains.dokka.links.DRI
-
-interface MarkdownToContentConverter {
-    fun buildContent(
-        docNode: DocNode,
-        dci: DCI,
-        platforms: Set<PlatformData>,
-        styles: Set<Style> = emptySet(),
-        extras: Set<Extra> = emptySet()
-    ): List<ContentNode>
-}
diff --git a/core/src/main/kotlin/pages/PageBuilder.kt b/core/src/main/kotlin/pages/PageBuilder.kt
index 8951219a..b1009a33 100644
--- a/core/src/main/kotlin/pages/PageBuilder.kt
+++ b/core/src/main/kotlin/pages/PageBuilder.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.pages
 
-import model.doc.DocType
+import org.jetbrains.dokka.model.doc.TagWrapper
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Function
 
@@ -46,12 +46,12 @@ class DefaultPageBuilder(
         header(1) { text("Package ${p.name}") }
         block("Types", 2, ContentKind.Properties, p.classes, p.platformData) {
             link(it.name, it.dri)
-            text(it.briefDocstring)
+            text(it.briefDocTagString)
         }
         block("Functions", 2, ContentKind.Functions, p.functions, p.platformData) {
             link(it.name, it.dri)
             signature(it)
-            text(it.briefDocstring)
+            text(it.briefDocTagString)
         }
     }
 
@@ -71,16 +71,16 @@ class DefaultPageBuilder(
         block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) {
             link(it.name, it.dri)
             signature(it)
-            text(it.briefDocstring)
+            text(it.briefDocTagString)
         }
         block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) {
             link(it.name, it.dri)
             signature(it)
-            text(it.briefDocstring)
+            text(it.briefDocTagString)
         }
         block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) {
             link(it.name, it.dri)
-            text(it.briefDocstring)
+            text(it.briefDocTagString)
         }
     }
 
@@ -94,7 +94,7 @@ class DefaultPageBuilder(
         }
     }
 
-    private fun DocType.toHeaderString() = this.javaClass.toGenericString().split('.').last()
+    private fun TagWrapper.toHeaderString() = this.javaClass.toGenericString().split('.').last()
 }
 
 typealias RootContentBuilder = (Documentable, Kind, PageContentBuilderFunction) -> ContentGroup
diff --git a/core/src/main/kotlin/pages/PageContentBuilder.kt b/core/src/main/kotlin/pages/PageContentBuilder.kt
index e3c924d1..cc53586e 100644
--- a/core/src/main/kotlin/pages/PageContentBuilder.kt
+++ b/core/src/main/kotlin/pages/PageContentBuilder.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.pages
 
-import model.doc.DocNode
+import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.model.Function
@@ -12,7 +12,7 @@ class DefaultPageContentBuilder(
     private val dri: DRI,
     private val platformData: Set<PlatformData>,
     private val kind: Kind,
-    private val markdownConverter: MarkdownToContentConverter,
+    private val commentsConverter: CommentsToContentConverter,
     val logger: DokkaLogger,
     private val styles: Set<Style> = emptySet(),
     private val extras: Set<Extra> = emptySet()
@@ -127,11 +127,11 @@ class DefaultPageContentBuilder(
         )
     }
 
-    override fun comment(docNode: DocNode) {
+    override fun comment(docTag: DocTag) {
         contents += group(ContentKind.Comment) {
             with(this as DefaultPageContentBuilder) {
-                contents += markdownConverter.buildContent(
-                    docNode,
+                contents += commentsConverter.buildContent(
+                    docTag,
                     DCI(dri, ContentKind.Comment),
                     platformData
                 )
@@ -147,18 +147,18 @@ class DefaultPageContentBuilder(
         platformData: Set<PlatformData>,
         kind: Kind,
         block: PageContentBuilderFunction
-    ): ContentGroup = group(dri, platformData, kind, markdownConverter, logger, block)
+    ): ContentGroup = group(dri, platformData, kind, commentsConverter, logger, block)
 
     companion object {
         fun group(
             dri: DRI,
             platformData: Set<PlatformData>,
             kind: Kind,
-            markdownConverter: MarkdownToContentConverter,
+            commentsConverter: CommentsToContentConverter,
             logger: DokkaLogger,
             block: PageContentBuilderFunction
         ): ContentGroup =
-            DefaultPageContentBuilder(dri, platformData, kind, markdownConverter, logger).apply(block).build()
+            DefaultPageContentBuilder(dri, platformData, kind, commentsConverter, logger).apply(block).build()
     }
 }
 
@@ -191,7 +191,7 @@ interface PageContentBuilder {
     fun link(text: String, address: DRI, kind: Kind = ContentKind.Symbol)
     fun link(address: DRI, kind: Kind = ContentKind.Symbol, block: PageContentBuilderFunction)
     fun linkTable(elements: List<DRI>)
-    fun comment(docNode: DocNode)
+    fun comment(docTag: DocTag)
     fun header(level: Int, block: PageContentBuilderFunction)
     fun <T> list(
         elements: List<T>,
diff --git a/core/src/main/kotlin/parsers/HtmlParser.kt b/core/src/main/kotlin/parsers/HtmlParser.kt
index 30f882b1..aebdee41 100644
--- a/core/src/main/kotlin/parsers/HtmlParser.kt
+++ b/core/src/main/kotlin/parsers/HtmlParser.kt
@@ -1,6 +1,6 @@
-package parsers
+package org.jetbrains.dokka.parsers
 
-import model.doc.*
+import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.parsers.factories.DocNodesFromStringFactory
 import org.jsoup.Jsoup
 import org.jsoup.nodes.Node
@@ -11,10 +11,10 @@ class HtmlParser : Parser() {
 
     inner class NodeFilterImpl : NodeFilter {
 
-        private val nodesCache: MutableMap<Int, MutableList<DocNode>> = mutableMapOf()
+        private val nodesCache: MutableMap<Int, MutableList<DocTag>> = mutableMapOf()
         private var currentDepth = 0
 
-        fun collect(): DocNode = nodesCache[currentDepth]!![0]
+        fun collect(): DocTag = nodesCache[currentDepth]!![0]
 
         override fun tail(node: Node?, depth: Int): NodeFilter.FilterResult {
             val nodeName = node!!.nodeName()
@@ -65,7 +65,7 @@ class HtmlParser : Parser() {
     }
 
 
-    private fun htmlToDocNode(string: String): DocNode {
+    private fun htmlToDocNode(string: String): DocTag {
         val document = Jsoup.parse(string)
         val nodeFilterImpl = NodeFilterImpl()
         NodeTraversor.filter(nodeFilterImpl, document.root())
diff --git a/core/src/main/kotlin/parsers/MarkdownParser.kt b/core/src/main/kotlin/parsers/MarkdownParser.kt
index 44c917e3..b4ebdac7 100644
--- a/core/src/main/kotlin/parsers/MarkdownParser.kt
+++ b/core/src/main/kotlin/parsers/MarkdownParser.kt
@@ -1,9 +1,10 @@
-package parsers
+package org.jetbrains.dokka.parsers
 
-import model.doc.*
+import org.jetbrains.dokka.model.doc.*
 import org.intellij.markdown.MarkdownElementTypes
 import org.intellij.markdown.MarkdownTokenTypes
 import org.intellij.markdown.ast.ASTNode
+import org.intellij.markdown.ast.CompositeASTNode
 import org.intellij.markdown.ast.impl.ListItemCompositeNode
 import org.intellij.markdown.flavours.commonmark.CommonMarkFlavourDescriptor
 import org.jetbrains.dokka.analysis.DokkaResolutionFacade
@@ -22,19 +23,25 @@ class MarkdownParser (
 
     inner class MarkdownVisitor(val text: String) {
 
-        private fun headersHandler(node: ASTNode): DocNode =
-            DocNodesFromIElementFactory.getInstance(node.type, visitNode(node.children.find { it.type == MarkdownTokenTypes.ATX_CONTENT }!!).children.drop(1))
+        private fun headersHandler(node: ASTNode): DocTag =
+            DocNodesFromIElementFactory.getInstance(
+                node.type,
+                visitNode(node.children.find { it.type == MarkdownTokenTypes.ATX_CONTENT }!!).children
+            )
 
-        private fun horizontalRulesHandler(node: ASTNode): DocNode =
+        private fun horizontalRulesHandler(node: ASTNode): DocTag =
             DocNodesFromIElementFactory.getInstance(MarkdownTokenTypes.HORIZONTAL_RULE)
 
-        private fun emphasisHandler(node: ASTNode): DocNode =
-            DocNodesFromIElementFactory.getInstance(node.type, children = listOf(visitNode(node.children[node.children.size/2])))
+        private fun emphasisHandler(node: ASTNode): DocTag =
+            DocNodesFromIElementFactory.getInstance(
+                node.type,
+                children = listOf(visitNode(node.children[node.children.size / 2]))
+            )
 
-        private fun blockquotesHandler(node: ASTNode): DocNode =
+        private fun blockquotesHandler(node: ASTNode): DocTag =
             DocNodesFromIElementFactory.getInstance(node.type, children = node.children.drop(1).map { visitNode(it) })
 
-        private fun listsHandler(node: ASTNode): DocNode {
+        private fun listsHandler(node: ASTNode): DocTag {
 
             val children = node.children.filterIsInstance<ListItemCompositeNode>().flatMap {
                 if( it.children.last().type in listOf(MarkdownElementTypes.ORDERED_LIST, MarkdownElementTypes.UNORDERED_LIST) ) {
@@ -57,8 +64,7 @@ class MarkdownParser (
                                 children = it
                                     .children
                                     .drop(1)
-                                    .filter { it.type !in listOf(MarkdownTokenTypes.WHITE_SPACE, MarkdownTokenTypes.EOL) }
-                                    .map { visitNode(it) }
+                                    .evaluateChildren()
                             )
                         else
                             visitNode(it)
@@ -72,7 +78,7 @@ class MarkdownParser (
             )
         }
 
-        private fun linksHandler(node: ASTNode): DocNode {
+        private fun linksHandler(node: ASTNode): DocTag {
             val linkNode = node.children.find { it.type == MarkdownElementTypes.LINK_LABEL }!!
             val link = text.substring(linkNode.startOffset+1, linkNode.endOffset-1)
 
@@ -91,19 +97,20 @@ class MarkdownParser (
             }
             val href = mapOf("href" to link)
             return when (node.type) {
-                MarkdownElementTypes.FULL_REFERENCE_LINK -> DocNodesFromIElementFactory.getInstance(node.type, params = href, children = node.children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!.children.drop(1).dropLast(1).map { visitNode(it) }, dri = dri)
+                MarkdownElementTypes.FULL_REFERENCE_LINK -> DocNodesFromIElementFactory.getInstance(node.type, params = href, children = node.children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!.children.drop(1).dropLast(1).evaluateChildren(), dri = dri)
                 else                                     -> DocNodesFromIElementFactory.getInstance(node.type, params = href, children = listOf(visitNode(linkNode)), dri = dri)
             }
         }
 
-        private fun imagesHandler(node: ASTNode): DocNode {
-            val linkNode = node.children.last().children.find { it.type == MarkdownElementTypes.LINK_LABEL }!!.children[1]
+        private fun imagesHandler(node: ASTNode): DocTag {
+            val linkNode =
+                node.children.last().children.find { it.type == MarkdownElementTypes.LINK_LABEL }!!.children[1]
             val link = text.substring(linkNode.startOffset, linkNode.endOffset)
             val src = mapOf("src" to link)
             return DocNodesFromIElementFactory.getInstance(node.type, params = src, children = listOf(visitNode(node.children.last().children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!)))
         }
 
-        private fun codeSpansHandler(node: ASTNode): DocNode =
+        private fun codeSpansHandler(node: ASTNode): DocTag =
             DocNodesFromIElementFactory.getInstance(
                 node.type,
                 children = listOf(
@@ -115,7 +122,7 @@ class MarkdownParser (
                 )
             )
 
-        private fun codeFencesHandler(node: ASTNode): DocNode =
+        private fun codeFencesHandler(node: ASTNode): DocTag =
             DocNodesFromIElementFactory.getInstance(
                 node.type,
                 children = node
@@ -129,13 +136,15 @@ class MarkdownParser (
                         ?: emptyMap()
             )
 
-        private fun codeBlocksHandler(node: ASTNode): DocNode =
-            DocNodesFromIElementFactory.getInstance(node.type, children = node.children.map { visitNode(it) })
+        private fun codeBlocksHandler(node: ASTNode): DocTag =
+            DocNodesFromIElementFactory.getInstance(node.type, children = node.children.evaluateChildren())
 
-        private fun defaultHandler(node: ASTNode): DocNode =
-            DocNodesFromIElementFactory.getInstance(MarkdownElementTypes.PARAGRAPH, children = node.children.map { visitNode(it) })
+        private fun defaultHandler(node: ASTNode): DocTag =
+            DocNodesFromIElementFactory.getInstance(
+                MarkdownElementTypes.PARAGRAPH,
+                children = node.children.evaluateChildren())
 
-        fun visitNode(node: ASTNode): DocNode =
+        fun visitNode(node: ASTNode): DocTag =
             when (node.type) {
                 MarkdownElementTypes.ATX_1,
                 MarkdownElementTypes.ATX_2,
@@ -155,16 +164,17 @@ class MarkdownParser (
                 MarkdownElementTypes.CODE_FENCE             -> codeFencesHandler(node)
                 MarkdownElementTypes.CODE_SPAN              -> codeSpansHandler(node)
                 MarkdownElementTypes.IMAGE                  -> imagesHandler(node)
-                MarkdownTokenTypes.EOL                      -> DocNodesFromIElementFactory.getInstance(MarkdownTokenTypes.TEXT, body = "\n")
-                MarkdownTokenTypes.WHITE_SPACE              -> DocNodesFromIElementFactory.getInstance(MarkdownTokenTypes.TEXT, body = " ")
                 MarkdownTokenTypes.CODE_FENCE_CONTENT,
                 MarkdownTokenTypes.CODE_LINE,
                 MarkdownTokenTypes.TEXT                     -> DocNodesFromIElementFactory.getInstance(MarkdownTokenTypes.TEXT, body = text.substring(node.startOffset, node.endOffset))
                 else                                        -> defaultHandler(node)
             }
+
+        private fun List<ASTNode>.evaluateChildren(): List<DocTag> =
+            this.filter { it is CompositeASTNode || it.type == MarkdownTokenTypes.TEXT }.map { visitNode(it) }
     }
 
-    private fun markdownToDocNode(text: String): DocNode {
+    private fun markdownToDocNode(text: String): DocTag {
 
         val flavourDescriptor = CommonMarkFlavourDescriptor()
         val markdownAstRoot: ASTNode = IntellijMarkdownParser(flavourDescriptor).buildMarkdownTreeFromString(text)
@@ -181,20 +191,23 @@ class MarkdownParser (
         else
             DocumentationNode(
                 (listOf(kDocTag) + kDocTag.children).filterIsInstance<KDocTag>().map {
-                    when( it.knownTag ) {
-                        null                        -> Description(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.AUTHOR         -> Author(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.THROWS         -> Throws(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
-                        KDocKnownTag.EXCEPTION      -> Throws(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
-                        KDocKnownTag.PARAM          -> Param(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
-                        KDocKnownTag.RECEIVER       -> Receiver(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.RETURN         -> Return(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.SEE            -> See(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
-                        KDocKnownTag.SINCE          -> Since(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.CONSTRUCTOR    -> Constructor(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.PROPERTY       -> Property(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
-                        KDocKnownTag.SAMPLE         -> Sample(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
-                        KDocKnownTag.SUPPRESS       -> Suppress(parseStringToDocNode(it.getContent()))
+                    when (it.knownTag) {
+                        null -> if (it.name == null) Description(parseStringToDocNode(it.getContent())) else CustomWrapperTag(
+                            parseStringToDocNode(it.getContent()),
+                            it.name!!
+                        )
+                        KDocKnownTag.AUTHOR -> Author(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.THROWS -> Throws(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.EXCEPTION -> Throws(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.PARAM -> Param(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.RECEIVER -> Receiver(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.RETURN -> Return(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.SEE -> See(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.SINCE -> Since(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.CONSTRUCTOR -> Constructor(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.PROPERTY -> Property(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.SAMPLE -> Sample(parseStringToDocNode(it.getContent()), it.getSubjectName()!!)
+                        KDocKnownTag.SUPPRESS -> Suppress(parseStringToDocNode(it.getContent()))
                     }
                 }
             )
diff --git a/core/src/main/kotlin/parsers/Parser.kt b/core/src/main/kotlin/parsers/Parser.kt
index a2a90dcd..daa9f38d 100644
--- a/core/src/main/kotlin/parsers/Parser.kt
+++ b/core/src/main/kotlin/parsers/Parser.kt
@@ -1,19 +1,19 @@
-package parsers
+package org.jetbrains.dokka.parsers
 
-import model.doc.*
-import model.doc.Deprecated
+import org.jetbrains.dokka.model.doc.*
+import org.jetbrains.dokka.model.doc.Deprecated
 
 
 abstract class Parser {
 
-    abstract fun parseStringToDocNode(extractedString: String): DocNode
+    abstract fun parseStringToDocNode(extractedString: String): DocTag
     abstract fun preparse(text: String): String
 
     fun parse(text: String): DocumentationNode {
 
         val list = jkdocToListOfPairs(preparse(text))
 
-        val mappedList: List<DocType> = list.map {
+        val mappedList: List<TagWrapper> = list.map {
             when(it.first) {
                 "description"         -> Description(parseStringToDocNode(it.second))
                 "author"              -> Author(parseStringToDocNode(it.second))
@@ -29,7 +29,7 @@ abstract class Parser {
                 "deprecated"          -> Deprecated(parseStringToDocNode(it.second))
                 "sample"              -> Sample(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
                 "suppress"            -> Suppress(parseStringToDocNode(it.second))
-                else                  -> CustomTag(parseStringToDocNode(it.second), it.first)
+                else                  -> CustomWrapperTag(parseStringToDocNode(it.second), it.first)
             }
         }
         return DocumentationNode(mappedList)
diff --git a/core/src/main/kotlin/parsers/factories/DocNodesFromIElementFactory.kt b/core/src/main/kotlin/parsers/factories/DocNodesFromIElementFactory.kt
index a93be0d3..1a302176 100644
--- a/core/src/main/kotlin/parsers/factories/DocNodesFromIElementFactory.kt
+++ b/core/src/main/kotlin/parsers/factories/DocNodesFromIElementFactory.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.parsers.factories
 
-import model.doc.*
+import org.jetbrains.dokka.model.doc.*
 import org.intellij.markdown.IElementType
 import org.intellij.markdown.MarkdownElementTypes
 import org.intellij.markdown.MarkdownTokenTypes
@@ -8,7 +8,7 @@ import org.jetbrains.dokka.links.DRI
 import java.lang.NullPointerException
 
 object DocNodesFromIElementFactory {
-    fun getInstance(type: IElementType, children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
+    fun getInstance(type: IElementType, children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
         when(type) {
             MarkdownElementTypes.SHORT_REFERENCE_LINK,
             MarkdownElementTypes.FULL_REFERENCE_LINK    -> if(dri == null) A(children, params) else DocumentationLink(children, params, dri)
@@ -31,6 +31,6 @@ object DocNodesFromIElementFactory {
             MarkdownElementTypes.PARAGRAPH              -> P(children, params)
             MarkdownTokenTypes.TEXT                     -> Text(children, params, body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"))
             MarkdownTokenTypes.HORIZONTAL_RULE          -> HorizontalRule()
-            else                                        -> CustomNode(children, params)
+            else                                        -> CustomDocTag(children, params)
         }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/factories/DocNodesFromStringFactory.kt b/core/src/main/kotlin/parsers/factories/DocNodesFromStringFactory.kt
index 49102ed0..6090cdb4 100644
--- a/core/src/main/kotlin/parsers/factories/DocNodesFromStringFactory.kt
+++ b/core/src/main/kotlin/parsers/factories/DocNodesFromStringFactory.kt
@@ -1,11 +1,11 @@
 package org.jetbrains.dokka.parsers.factories
 
-import model.doc.*
+import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.links.DRI
 import java.lang.NullPointerException
 
 object DocNodesFromStringFactory {
-    fun getInstance(name: String, children: List<DocNode> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
+    fun getInstance(name: String, children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
         when(name) {
             "a" -> A(children, params)
             "big" -> Big(children, params)
@@ -71,6 +71,6 @@ object DocNodesFromStringFactory {
             "var" -> Var(children, params)
             "documentationlink" -> DocumentationLink(children, params, dri ?: throw NullPointerException("DRI cannot be passed null while constructing documentation link!"))
             "hr" -> HorizontalRule()
-            else -> CustomNode(children, params)
+            else -> CustomDocTag(children, params)
         }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index e46ade01..86ca5ca8 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.pages.DocNodeToContentConverter
+import org.jetbrains.dokka.pages.DocTagToContentConverter
 import org.jetbrains.dokka.renderers.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProvider
 import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
@@ -14,7 +14,7 @@ object DefaultExtensions : DokkaExtensionHandler {
         when (point) {
             CoreExtensions.descriptorToDocumentationTranslator -> DefaultDescriptorToDocumentationTranslator
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
-            CoreExtensions.markdownToContentConverterFactory -> ::DocNodeToContentConverter
+            CoreExtensions.commentsToContentConverterFactory -> ::DocTagToContentConverter
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
             CoreExtensions.rendererFactory -> ::HtmlRenderer
             CoreExtensions.locationProviderFactory -> ::DefaultLocationProvider
diff --git a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
index bdd345f1..389a265f 100644
--- a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
+++ b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.KotlinType
-import parsers.MarkdownParser
+import org.jetbrains.dokka.parsers.MarkdownParser
 
 object DefaultDescriptorToDocumentationTranslator: DescriptorToDocumentationTranslator {
     override fun invoke(
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
index c6813ef8..32053aa0 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
@@ -16,7 +16,7 @@ object DefaultDocumentationToPageTranslator : DocumentationToPageTranslator {
                 node.dri,
                 node.platformData,
                 kind,
-                context.single(CoreExtensions.markdownToContentConverterFactory).invoke(context),
+                context.single(CoreExtensions.commentsToContentConverterFactory).invoke(context),
                 context.logger,
                 operation
             )
diff --git a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
index 9b3c25c2..32294ea8 100644
--- a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
+++ b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
@@ -1,6 +1,7 @@
 package  org.jetbrains.dokka.mathjax
 
-import model.doc.CustomTag
+
+import org.jetbrains.dokka.model.doc.CustomWrapperTag
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.pages.PageNode
@@ -14,7 +15,7 @@ class MathjaxPlugin : DokkaPlugin() {
     }
 }
 
-private const val ANNOTATION = "@usesMathJax"
+private const val ANNOTATION = "usesMathJax"
 private const val LIB_PATH = "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.6/MathJax.js?config=TeX-AMS_SVG&latest"
 
 object MathjaxTransformer : PageNodeTransformer {
@@ -32,9 +33,5 @@ object MathjaxTransformer : PageNodeTransformer {
         get() = documentable?.platformInfo
             ?.flatMap { it.documentationNode.children }
             .orEmpty()
-            .filterIsInstance<CustomTag>()
-            .let { true }
-//            .any { it.name.contains("ref") && it.root.children.any {it.name} }
-
-
+            .any { (it as? CustomWrapperTag)?.name == ANNOTATION }
 }
\ No newline at end of file
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index 961a6387..1f496b33 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -38,14 +38,14 @@ object XmlTransformer : PageNodeTransformer {
                     node.dri,
                     platformData,
                     XMLKind.XmlList,
-                    dokkaContext.single(CoreExtensions.markdownToContentConverterFactory).invoke(dokkaContext),
+                    dokkaContext.single(CoreExtensions.commentsToContentConverterFactory).invoke(dokkaContext),
                     dokkaContext.logger
                 ) {
                     block("XML Attributes", 2, XMLKind.XmlList, elementsToAdd, platformData) { element ->
                         link(element.dri, XMLKind.XmlList) {
                             text(element.name ?: "<unnamed>", XMLKind.Main)
                         }
-                        text(element.briefDocstring, XMLKind.XmlList)
+                        text(element.briefDocTagString, XMLKind.XmlList)
                     }
                 }
 
-- 
cgit 


From e1dad14904ca0e3b727cf0d7239db35f5402e775 Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Thu, 19 Dec 2019 15:02:03 +0100
Subject: Resolved problems with plugins loading ordering and added type safe
 ordering function

---
 .idea/jarRepositories.xml                        | 80 ++++++++++++++++++++++++
 core/src/main/kotlin/plugability/DokkaContext.kt | 52 +++++++++++++--
 core/src/main/kotlin/plugability/DokkaPlugin.kt  |  4 +-
 core/src/main/kotlin/plugability/extensions.kt   | 41 +++++++++---
 4 files changed, 162 insertions(+), 15 deletions(-)
 create mode 100644 .idea/jarRepositories.xml

(limited to 'core/src/main/kotlin/plugability')

diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
new file mode 100644
index 00000000..d92018c5
--- /dev/null
+++ b/.idea/jarRepositories.xml
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="RemoteRepositoriesConfiguration">
+    <remote-repository>
+      <option name="id" value="central" />
+      <option name="name" value="Maven Central repository" />
+      <option name="url" value="https://repo1.maven.org/maven2" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="jboss.community" />
+      <option name="name" value="JBoss Community repository" />
+      <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven8" />
+      <option name="name" value="maven8" />
+      <option name="url" value="https://www.jetbrains.com/intellij-repository/snapshots" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven5" />
+      <option name="name" value="maven5" />
+      <option name="url" value="https://kotlin.bintray.com/kotlinx" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="MavenRepo" />
+      <option name="name" value="MavenRepo" />
+      <option name="url" value="https://repo.maven.apache.org/maven2/" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven4" />
+      <option name="name" value="maven4" />
+      <option name="url" value="https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/1.3.20-dev-564/maven" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven7" />
+      <option name="name" value="maven7" />
+      <option name="url" value="https://dl.bintray.com/orangy/maven" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven" />
+      <option name="name" value="maven" />
+      <option name="url" value="https://dl.bintray.com/jetbrains/markdown" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="BintrayJCenter" />
+      <option name="name" value="BintrayJCenter" />
+      <option name="url" value="https://jcenter.bintray.com/" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven9" />
+      <option name="name" value="maven9" />
+      <option name="url" value="https://www.jetbrains.com/intellij-repository/releases" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven2" />
+      <option name="name" value="maven2" />
+      <option name="url" value="https://dl.bintray.com/kotlin/kotlin-eap" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven3" />
+      <option name="name" value="maven3" />
+      <option name="url" value="https://dl.bintray.com/kotlin/kotlin-dev" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="MavenLocal" />
+      <option name="name" value="MavenLocal" />
+      <option name="url" value="file:$MAVEN_REPOSITORY$" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven6" />
+      <option name="name" value="maven6" />
+      <option name="url" value="https://dl.bintray.com/kotlin/kotlinx" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="Google" />
+      <option name="name" value="Google" />
+      <option name="url" value="https://dl.google.com/dl/android/maven2/" />
+    </remote-repository>
+  </component>
+</project>
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 7b1c1306..8709b74f 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -36,6 +36,7 @@ interface DokkaContext : DokkaExtensionHandler {
                     .also { checkClasspath(it) }
                     .let { ServiceLoader.load(DokkaPlugin::class.java, it) }
                     .forEach { install(it) }
+                applyExtensions()
             }.also { it.logInitialisationInfo() }
     }
 }
@@ -54,7 +55,7 @@ fun <T, E> DokkaContext.single(point: E): T where T : Any, E : ExtensionPoint<T>
 }
 
 interface DokkaContextConfiguration {
-    fun addExtension(extension: Extension<*>)
+    fun addExtensionDependencies(extension: Extension<*>)
 }
 
 private class DokkaContextConfigurationImpl(
@@ -63,11 +64,43 @@ private class DokkaContextConfigurationImpl(
     override val platforms: Map<PlatformData, EnvironmentAndFacade>
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
-
     private val pluginStubs = mutableMapOf<KClass<*>, DokkaPlugin>()
-
     internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
 
+    private enum class State {
+        UNVISITED,
+        VISITING,
+        VISITED;
+    }
+
+    internal val verticesWithState = mutableMapOf<Extension<*>, State>()
+    internal val adjacencyList: MutableMap<Extension<*>, MutableList<Extension<*>>> = mutableMapOf()
+
+    private fun topologicalSort() {
+
+        val result: MutableList<Extension<*>> = mutableListOf()
+
+        fun visit(n: Extension<*>) {
+            val state = verticesWithState[n]
+            if(state == State.VISITED)
+                return
+            if(state == State.VISITING)
+                throw Error("Detected cycle in plugins graph")
+            verticesWithState[n] = State.VISITING
+            adjacencyList[n]?.forEach { visit(it) }
+            verticesWithState[n] = State.VISITED
+            result += n
+        }
+
+        for((vertex, state) in verticesWithState) {
+            if(state == State.UNVISITED)
+                visit(vertex)
+        }
+        result.asReversed().forEach {
+            extensions.getOrPut(it.extensionPoint, ::mutableListOf) += it
+        }
+    }
+
     @Suppress("UNCHECKED_CAST")
     override operator fun <T, E> get(point: E, askDefault: AskDefault) where T : Any, E : ExtensionPoint<T> =
         when (askDefault) {
@@ -91,8 +124,13 @@ private class DokkaContextConfigurationImpl(
         plugin.internalInstall(this)
     }
 
-    override fun addExtension(extension: Extension<*>) {
-        extensions.getOrPut(extension.extensionPoint, ::mutableListOf) += extension
+    override fun addExtensionDependencies(extension: Extension<*>) {
+        val orderDsl = OrderDsl()
+        extension.ordering?.invoke(orderDsl)
+
+        verticesWithState += extension to State.UNVISITED
+        adjacencyList.getOrPut(extension, ::mutableListOf) += orderDsl.following.toList()
+        orderDsl.previous.forEach { adjacencyList.getOrPut(it, ::mutableListOf) += extension }
     }
 
     fun logInitialisationInfo() {
@@ -105,6 +143,10 @@ private class DokkaContextConfigurationImpl(
         logger.progress("Loaded: $loadedListForDebug")
 
     }
+
+    fun applyExtensions() {
+        topologicalSort()
+    }
 }
 
 private fun checkClasspath(classLoader: URLClassLoader) {
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 7a968b8b..3f82000d 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -40,8 +40,6 @@ abstract class DokkaPlugin {
         extensionDelegates.asSequence()
             .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // should be always true
             .map { it.get(this) }
-            .forEach { ctx.addExtension(it) }
+            .forEach { ctx.addExtensionDependencies(it) }
     }
-
-
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index 3039cb5a..8d1a7ba0 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -7,7 +7,7 @@ data class ExtensionPoint<T : Any> internal constructor(
     override fun toString() = "ExtensionPoint: $pluginClass/$pointName"
 }
 
-class Extension<T : Any> internal constructor(
+abstract class Extension<T : Any> internal constructor(
     internal val extensionPoint: ExtensionPoint<T>,
     internal val pluginClass: String,
     internal val extensionName: String,
@@ -17,12 +17,39 @@ class Extension<T : Any> internal constructor(
     override fun toString() = "Extension: $pluginClass/$extensionName"
 
     override fun equals(other: Any?) =
-        if (other is Extension<*>) this.pluginClass == other.extensionName && this.extensionName == other.extensionName
+        if (other is Extension<*>) this.pluginClass == other.pluginClass && this.extensionName == other.extensionName
         else false
 
     override fun hashCode() = listOf(pluginClass, extensionName).hashCode()
 }
 
+class ExtensionOrdered<T : Any>(
+    extensionPoint: ExtensionPoint<T>,
+    pluginClass: String,
+    extensionName: String,
+    action: T,
+    ordering: (OrderDsl.() -> Unit)
+) : Extension<T>(
+    extensionPoint,
+    pluginClass,
+    extensionName,
+    action,
+    ordering
+)
+
+class ExtensionUnordered<T : Any>(
+    extensionPoint: ExtensionPoint<T>,
+    pluginClass: String,
+    extensionName: String,
+    action: T
+) : Extension<T>(
+    extensionPoint,
+    pluginClass,
+    extensionName,
+    action,
+    null
+)
+
 internal data class Ordering(val previous: Set<Extension<*>>, val following: Set<Extension<*>>)
 
 @DslMarker
@@ -31,16 +58,16 @@ annotation class ExtensionsDsl
 @ExtensionsDsl
 class ExtendingDSL(private val pluginClass: String, private val extensionName: String) {
     infix fun <T: Any> ExtensionPoint<T>.with(action: T) =
-        Extension(this, this@ExtendingDSL.pluginClass, extensionName, action)
+        ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, action)
 
-    infix fun <T: Any> Extension<T>.order(block: OrderDsl.() -> Unit) =
-        Extension(extensionPoint, pluginClass, extensionName, action, block)
+    infix fun <T: Any> ExtensionUnordered<T>.order(block: OrderDsl.() -> Unit) =
+        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, block)
 }
 
 @ExtensionsDsl
 class OrderDsl {
-    private val previous = mutableSetOf<Extension<*>>()
-    private val following = mutableSetOf<Extension<*>>()
+    internal val previous = mutableSetOf<Extension<*>>()
+    internal val following = mutableSetOf<Extension<*>>()
 
     fun after(vararg extensions: Extension<*>) {
         previous += extensions
-- 
cgit 


From 0917459a2eafabc563e79579a0322bb7832cae1f Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Fri, 13 Dec 2019 14:27:25 +0100
Subject: Refactor of DokkaGenerator pipeline, removed ExtensionPoints
 dependencies other than context

---
 core/src/main/kotlin/CoreExtensions.kt                 | 13 ++++++-------
 core/src/main/kotlin/DokkaGenerator.kt                 | 16 +++++-----------
 core/src/main/kotlin/plugability/DefaultExtensions.kt  | 18 ++++++++++--------
 core/src/main/kotlin/plugability/DokkaContext.kt       | 17 +++++++++--------
 core/src/main/kotlin/plugability/LazyEvaluated.kt      | 16 ++++++++++++++++
 core/src/main/kotlin/plugability/extensions.kt         | 18 +++++++++++-------
 core/src/main/kotlin/renderers/DefaultRenderer.kt      | 14 ++++++++++----
 core/src/main/kotlin/renderers/FileWriter.kt           |  4 ++--
 core/src/main/kotlin/renderers/HtmlRenderer.kt         |  9 ++++-----
 core/src/main/kotlin/renderers/OutputWriter.kt         |  6 ++++++
 .../main/kotlin/resolvers/DefaultLocationProvider.kt   |  5 ++---
 .../main/kotlin/resolvers/LocationProviderFactory.kt   | 13 +++++++++++++
 .../DefaultDocumentationToPageTranslator.kt            |  2 +-
 plugins/xml/src/main/kotlin/XmlPlugin.kt               |  2 +-
 14 files changed, 96 insertions(+), 57 deletions(-)
 create mode 100644 core/src/main/kotlin/plugability/LazyEvaluated.kt
 create mode 100644 core/src/main/kotlin/renderers/OutputWriter.kt
 create mode 100644 core/src/main/kotlin/resolvers/LocationProviderFactory.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 191a6c59..c1871118 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -1,12 +1,10 @@
 package org.jetbrains.dokka
 
 import org.jetbrains.dokka.pages.CommentsToContentConverter
-import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.ExtensionPoint
 import org.jetbrains.dokka.renderers.Renderer
-import org.jetbrains.dokka.renderers.Writer
-import org.jetbrains.dokka.resolvers.LocationProvider
+import org.jetbrains.dokka.renderers.OutputWriter
+import org.jetbrains.dokka.resolvers.LocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTranslator
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeTransformer
@@ -23,11 +21,12 @@ object CoreExtensions {
     val descriptorToDocumentationTranslator by coreExtension<DescriptorToDocumentationTranslator>()
     val documentationMerger by coreExtension<DocumentationNodeMerger>()
     val documentationTransformer by coreExtension<DocumentationNodeTransformer>()
-    val commentsToContentConverterFactory by coreExtension<(DokkaContext) -> CommentsToContentConverter>()
+    val commentsToContentConverter by coreExtension<CommentsToContentConverter>()
     val documentationToPageTranslator by coreExtension<DocumentationToPageTranslator>()
     val pageTransformer by coreExtension<PageNodeTransformer>()
-    val rendererFactory by coreExtension<(Writer, LocationProvider, DokkaContext) -> Renderer>()
-    val locationProviderFactory by coreExtension<(root: PageNode, DokkaConfiguration, DokkaContext) -> LocationProvider>()
+    val locationProviderFactory by coreExtension<LocationProviderFactory>()
+    val outputWriter by coreExtension<OutputWriter>()
+    val renderer by coreExtension<Renderer>()
     val fileExtension by coreExtension<String>()
 
     private fun <T: Any> coreExtension() = object {
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 0812dd5b..06de6c27 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -30,7 +30,7 @@ class DokkaGenerator(
         val platforms: Map<PlatformData, EnvironmentAndFacade> = setUpAnalysis(configuration)
 
         logger.progress("Initializing plugins")
-        val context = initializePlugins(configuration.pluginsClasspath, logger, platforms)
+        val context = initializePlugins(configuration, logger, platforms)
 
         logger.progress("Creating documentation models")
         val modulesFromPlatforms = createDocumentationModels(platforms, context)
@@ -48,7 +48,7 @@ class DokkaGenerator(
         val transformedPages = transformPages(pages, context)
 
         logger.progress("Rendering")
-        render(transformedPages, configuration, context)
+        render(transformedPages, context)
     }
 
     internal fun setUpAnalysis(configuration: DokkaConfiguration): Map<PlatformData, EnvironmentAndFacade> =
@@ -57,10 +57,10 @@ class DokkaGenerator(
         }.toMap()
 
     internal fun initializePlugins(
-        pluginsClasspath: List<File>,
+        configuration: DokkaConfiguration,
         logger: DokkaLogger,
         platforms: Map<PlatformData, EnvironmentAndFacade>
-    ) = DokkaContext.create(pluginsClasspath, logger, platforms)
+    ) = DokkaContext.create(configuration, logger, platforms)
 
     internal fun createDocumentationModels(
         platforms: Map<PlatformData, EnvironmentAndFacade>,
@@ -89,15 +89,9 @@ class DokkaGenerator(
 
     internal fun render(
         transformedPages: ModulePageNode,
-        configuration: DokkaConfiguration,
         context: DokkaContext
     ) {
-        val fileWriter = FileWriter(configuration.outputDir, "")
-        val locationProvider = context.single(CoreExtensions.locationProviderFactory)
-            .invoke(transformedPages, configuration, context)
-        val renderer = context.single(CoreExtensions.rendererFactory)
-            .invoke(fileWriter, locationProvider, context)
-
+        val renderer = context.single(CoreExtensions.renderer)
         renderer.render(transformedPages)
     }
 
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 86ca5ca8..58b686f3 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -2,23 +2,25 @@ package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.DocTagToContentConverter
+import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.HtmlRenderer
-import org.jetbrains.dokka.resolvers.DefaultLocationProvider
+import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
 
-object DefaultExtensions : DokkaExtensionHandler {
+internal object DefaultExtensions {
     @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
-    override fun <T : Any, E : ExtensionPoint<T>> get(point: E, askDefault: AskDefault): List<T> =
+    internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
-            CoreExtensions.descriptorToDocumentationTranslator -> DefaultDescriptorToDocumentationTranslator
+            CoreExtensions.descriptorToDocumentationTranslator ->  DefaultDescriptorToDocumentationTranslator
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
-            CoreExtensions.commentsToContentConverterFactory -> ::DocTagToContentConverter
+            CoreExtensions.commentsToContentConverter -> DocTagToContentConverter(fullContext)
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
-            CoreExtensions.rendererFactory -> ::HtmlRenderer
-            CoreExtensions.locationProviderFactory -> ::DefaultLocationProvider
+            CoreExtensions.renderer -> HtmlRenderer(fullContext.single(CoreExtensions.outputWriter), fullContext)
+            CoreExtensions.locationProviderFactory -> DefaultLocationProviderFactory
+            CoreExtensions.outputWriter ->  FileWriter(fullContext.configuration.outputDir, "")
             CoreExtensions.fileExtension -> ".html"
             else -> null
-        }.let { listOfNotNull(it) as List<T> }
+        }.let { listOfNotNull( it ) as List<T> }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 8709b74f..f2c99d95 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.plugability
 
+import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.pages.PlatformData
@@ -20,17 +21,17 @@ interface DokkaContext : DokkaExtensionHandler {
     fun <T : DokkaPlugin> plugin(kclass: KClass<T>): T?
 
     val logger: DokkaLogger
-
+    val configuration: DokkaConfiguration
     val platforms: Map<PlatformData, EnvironmentAndFacade>
 
     companion object {
         fun create(
-            pluginsClasspath: Iterable<File>,
+            configuration: DokkaConfiguration,
             logger: DokkaLogger,
             platforms: Map<PlatformData, EnvironmentAndFacade>
         ): DokkaContext =
-            DokkaContextConfigurationImpl(logger, DefaultExtensions, platforms).apply {
-                pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
+            DokkaContextConfigurationImpl(logger, configuration, platforms).apply {
+                configuration.pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
                     .toTypedArray()
                     .let { URLClassLoader(it, this.javaClass.classLoader) }
                     .also { checkClasspath(it) }
@@ -60,7 +61,7 @@ interface DokkaContextConfiguration {
 
 private class DokkaContextConfigurationImpl(
     override val logger: DokkaLogger,
-    private val defaultHandler: DokkaExtensionHandler?,
+    override val configuration: DokkaConfiguration,
     override val platforms: Map<PlatformData, EnvironmentAndFacade>
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
@@ -105,12 +106,12 @@ private class DokkaContextConfigurationImpl(
     override operator fun <T, E> get(point: E, askDefault: AskDefault) where T : Any, E : ExtensionPoint<T> =
         when (askDefault) {
             AskDefault.Never -> actions(point).orEmpty()
-            AskDefault.Always -> actions(point).orEmpty() + defaultHandler?.get(point, askDefault).orEmpty()
+            AskDefault.Always -> actions(point).orEmpty() + DefaultExtensions.get(point, this)
             AskDefault.WhenEmpty ->
-                actions(point)?.takeIf { it.isNotEmpty() } ?: defaultHandler?.get(point, askDefault).orEmpty()
+                actions(point)?.takeIf { it.isNotEmpty() } ?: DefaultExtensions?.get(point, this)
         } as List<T>
 
-    private fun <E : ExtensionPoint<*>> actions(point: E) = extensions[point]?.map { it.action }
+    private fun <E : ExtensionPoint<*>> actions(point: E) = extensions[point]?.map { it.action.get(this) }
 
     @Suppress("UNCHECKED_CAST")
     override fun <T : DokkaPlugin> plugin(kclass: KClass<T>) = (plugins[kclass] ?: pluginStubFor(kclass)) as T
diff --git a/core/src/main/kotlin/plugability/LazyEvaluated.kt b/core/src/main/kotlin/plugability/LazyEvaluated.kt
new file mode 100644
index 00000000..79ac0968
--- /dev/null
+++ b/core/src/main/kotlin/plugability/LazyEvaluated.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.dokka.plugability
+
+internal class LazyEvaluated<T : Any> private constructor(private val recipe: ((DokkaContext) -> T)? = null, private var value: T? = null) {
+
+    internal fun get(context: DokkaContext): T {
+        if(value != null) {
+            value = recipe?.invoke(context)
+        }
+        return value ?: throw AssertionError("Incorrect initialized LazyEvaluated instance")
+    }
+
+    companion object {
+        fun <T : Any> fromInstance(value: T) = LazyEvaluated(value = value)
+        fun <T : Any> fromRecipe(recipe: (DokkaContext) -> T) = LazyEvaluated(recipe = recipe)
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index 8d1a7ba0..42bf3900 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -11,7 +11,7 @@ abstract class Extension<T : Any> internal constructor(
     internal val extensionPoint: ExtensionPoint<T>,
     internal val pluginClass: String,
     internal val extensionName: String,
-    val action: T,
+    internal val action: LazyEvaluated<T>,
     internal val ordering: (OrderDsl.() -> Unit)? = null
 ) {
     override fun toString() = "Extension: $pluginClass/$extensionName"
@@ -23,11 +23,11 @@ abstract class Extension<T : Any> internal constructor(
     override fun hashCode() = listOf(pluginClass, extensionName).hashCode()
 }
 
-class ExtensionOrdered<T : Any>(
+class ExtensionOrdered<T : Any> internal constructor(
     extensionPoint: ExtensionPoint<T>,
     pluginClass: String,
     extensionName: String,
-    action: T,
+    action: LazyEvaluated<T>,
     ordering: (OrderDsl.() -> Unit)
 ) : Extension<T>(
     extensionPoint,
@@ -37,11 +37,11 @@ class ExtensionOrdered<T : Any>(
     ordering
 )
 
-class ExtensionUnordered<T : Any>(
+class ExtensionUnordered<T : Any> internal constructor(
     extensionPoint: ExtensionPoint<T>,
     pluginClass: String,
     extensionName: String,
-    action: T
+    action: LazyEvaluated<T>
 ) : Extension<T>(
     extensionPoint,
     pluginClass,
@@ -57,8 +57,12 @@ annotation class ExtensionsDsl
 
 @ExtensionsDsl
 class ExtendingDSL(private val pluginClass: String, private val extensionName: String) {
-    infix fun <T: Any> ExtensionPoint<T>.with(action: T) =
-        ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, action)
+
+    infix fun <T : Any> ExtensionPoint<T>.with(action: T) =
+        ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromInstance(action))
+
+    infix fun <T : Any> ExtensionPoint<T>.providing(action: (DokkaContext) -> T) =
+        ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromRecipe(action))
 
     infix fun <T: Any> ExtensionUnordered<T>.order(block: OrderDsl.() -> Unit) =
         ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, block)
diff --git a/core/src/main/kotlin/renderers/DefaultRenderer.kt b/core/src/main/kotlin/renderers/DefaultRenderer.kt
index 8f6c6635..5f982251 100644
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/core/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -1,15 +1,20 @@
 package org.jetbrains.dokka.renderers
 
+import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.resolvers.LocationProvider
 
+
 abstract class DefaultRenderer<T>(
-    protected val writer: Writer,
-    protected val locationProvider: LocationProvider,
+    protected val outputWriter: OutputWriter,
     protected val context: DokkaContext
 ) : Renderer {
 
+    protected lateinit var locationProvider: LocationProvider
+        private set
+
     protected abstract fun T.buildHeader(level: Int, content: T.() -> Unit)
     protected abstract fun T.buildLink(address: String, content: T.() -> Unit)
     protected abstract fun T.buildList(node: ContentList, pageContext: PageNode)
@@ -64,7 +69,7 @@ abstract class DefaultRenderer<T>(
     }
 
     protected open fun renderPage(page: PageNode) =
-        writer.write(locationProvider.resolve(page), buildPage(page, ::buildPageContent), "")
+        outputWriter.write(locationProvider.resolve(page), buildPage(page, ::buildPageContent), "")
 
     protected open fun renderPages(root: PageNode) {
         renderPage(root)
@@ -77,7 +82,7 @@ abstract class DefaultRenderer<T>(
         getPackageNamesAndPlatforms(root)
             .keys
             .joinToString("\n")
-            .also { writer.write("${root.name}/package-list", it, "") }
+            .also { outputWriter.write("${root.name}/package-list", it, "") }
 
     protected open fun getPackageNamesAndPlatforms(root: PageNode): Map<String, List<PlatformData>> =
         root.children
@@ -90,6 +95,7 @@ abstract class DefaultRenderer<T>(
                 }
 
     override fun render(root: PageNode) {
+        locationProvider = context.single(CoreExtensions.locationProviderFactory).getLocationProvider(root, context)
         renderPackageList(root)
         buildSupportFiles()
         renderPages(root)
diff --git a/core/src/main/kotlin/renderers/FileWriter.kt b/core/src/main/kotlin/renderers/FileWriter.kt
index c9785dfd..5439db17 100644
--- a/core/src/main/kotlin/renderers/FileWriter.kt
+++ b/core/src/main/kotlin/renderers/FileWriter.kt
@@ -4,10 +4,10 @@ import java.io.File
 import java.io.IOException
 import java.nio.file.Paths
 
-class FileWriter(override val root: String, override val extension: String) : Writer {
+class FileWriter(val root: String, override val extension: String): OutputWriter {
     private val createdFiles: MutableSet<String> = mutableSetOf()
 
-    override fun write(path: String, text: String, ext: String){
+    override fun write(path: String, text: String, ext: String) {
         if (createdFiles.contains(path)) {
             println("ERROR. An attempt to write $root/$path several times!")
             return
diff --git a/core/src/main/kotlin/renderers/HtmlRenderer.kt b/core/src/main/kotlin/renderers/HtmlRenderer.kt
index 2bb07666..68d6d276 100644
--- a/core/src/main/kotlin/renderers/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/HtmlRenderer.kt
@@ -4,15 +4,13 @@ import kotlinx.html.*
 import kotlinx.html.stream.appendHTML
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.resolvers.LocationProvider
 import java.io.File
 import java.net.URL
 
 open class HtmlRenderer(
-    writer: Writer,
-    locationProvider: LocationProvider,
+    outputWriter: OutputWriter,
     context: DokkaContext
-) : DefaultRenderer<FlowContent>(writer, locationProvider, context) {
+) : DefaultRenderer<FlowContent>(outputWriter, context) {
 
     override fun FlowContent.buildList(node: ContentList, pageContext: PageNode) =
         if (node.ordered) ol {
@@ -120,8 +118,9 @@ open class HtmlRenderer(
         text(textNode.text)
     }
 
+
     override fun buildSupportFiles() { // TODO copy file instead of reading
-        writer.write(
+        outputWriter.write(
             "style.css",
             javaClass.getResourceAsStream("/dokka/styles/style.css").reader().readText()
         )
diff --git a/core/src/main/kotlin/renderers/OutputWriter.kt b/core/src/main/kotlin/renderers/OutputWriter.kt
new file mode 100644
index 00000000..84cc124d
--- /dev/null
+++ b/core/src/main/kotlin/renderers/OutputWriter.kt
@@ -0,0 +1,6 @@
+package org.jetbrains.dokka.renderers
+
+interface OutputWriter{
+    val extension: String
+    fun write(path: String, text: String, ext: String = extension)
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
index 7442f449..7eae26ca 100644
--- a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
+++ b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
@@ -10,8 +10,7 @@ import org.jetbrains.dokka.plugability.single
 
 open class DefaultLocationProvider(
     private val pageGraphRoot: ModulePageNode,
-    private val configuration: DokkaConfiguration,
-    context: DokkaContext
+    private val context: DokkaContext
 ) : LocationProvider { // TODO: cache
     private val extension = context.single(CoreExtensions.fileExtension)
 
@@ -21,7 +20,7 @@ open class DefaultLocationProvider(
         findInPageGraph(dri, platforms)?.let { resolve(it, context) } ?:
         // Not found in PageGraph, that means it's an external link
         ExternalLocationProvider.getLocation(dri,
-            configuration.passesConfigurations
+            this@DefaultLocationProvider.context.configuration.passesConfigurations
                 .filter { passConfig ->
                     platforms.toSet().contains(PlatformData(passConfig.moduleName, passConfig.analysisPlatform, passConfig.targets))
                 } // TODO: change targets to something better?
diff --git a/core/src/main/kotlin/resolvers/LocationProviderFactory.kt b/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
new file mode 100644
index 00000000..1622045b
--- /dev/null
+++ b/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
@@ -0,0 +1,13 @@
+package org.jetbrains.dokka.resolvers
+
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface LocationProviderFactory {
+    fun getLocationProvider(pageNode: PageNode, context: DokkaContext): LocationProvider
+}
+
+object DefaultLocationProviderFactory : LocationProviderFactory {
+    override fun getLocationProvider(pageNode: PageNode, context: DokkaContext)  = DefaultLocationProvider(pageNode as ModulePageNode, context)
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
index 32053aa0..20180ba7 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
@@ -16,7 +16,7 @@ object DefaultDocumentationToPageTranslator : DocumentationToPageTranslator {
                 node.dri,
                 node.platformData,
                 kind,
-                context.single(CoreExtensions.commentsToContentConverterFactory).invoke(context),
+                context.single(CoreExtensions.commentsToContentConverter),
                 context.logger,
                 operation
             )
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index 1f496b33..839929e6 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -38,7 +38,7 @@ object XmlTransformer : PageNodeTransformer {
                     node.dri,
                     platformData,
                     XMLKind.XmlList,
-                    dokkaContext.single(CoreExtensions.commentsToContentConverterFactory).invoke(dokkaContext),
+                    dokkaContext.single(CoreExtensions.commentsToContentConverter),
                     dokkaContext.logger
                 ) {
                     block("XML Attributes", 2, XMLKind.XmlList, elementsToAdd, platformData) { element ->
-- 
cgit 


From 69d2663ff7de9fb4e4b1d0bc0b82f7653f70dad1 Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Thu, 16 Jan 2020 10:51:55 +0100
Subject: Applies requested changes

---
 core/src/main/kotlin/plugability/DefaultExtensions.kt     | 12 +++++++++---
 core/src/main/kotlin/plugability/DokkaContext.kt          |  9 +++------
 core/src/main/kotlin/plugability/LazyEvaluated.kt         |  2 +-
 core/src/main/kotlin/renderers/DefaultRenderer.kt         |  2 +-
 core/src/main/kotlin/resolvers/DefaultLocationProvider.kt |  6 +++---
 core/src/main/kotlin/resolvers/LocationProviderFactory.kt |  8 ++++----
 6 files changed, 21 insertions(+), 18 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 58b686f3..b3ff4248 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -10,15 +10,21 @@ import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMe
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
 
 internal object DefaultExtensions {
+
+    private val renderer: LazyEvaluated<HtmlRenderer> = LazyEvaluated.fromRecipe { HtmlRenderer(it.single(CoreExtensions.outputWriter), it) }
+    private val converter: LazyEvaluated<DocTagToContentConverter> = LazyEvaluated.fromRecipe {DocTagToContentConverter(it) }
+    private val providerFactory: LazyEvaluated<DefaultLocationProviderFactory> = LazyEvaluated.fromRecipe { DefaultLocationProviderFactory(it) }
+
+
     @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
             CoreExtensions.descriptorToDocumentationTranslator ->  DefaultDescriptorToDocumentationTranslator
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
-            CoreExtensions.commentsToContentConverter -> DocTagToContentConverter(fullContext)
+            CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
-            CoreExtensions.renderer -> HtmlRenderer(fullContext.single(CoreExtensions.outputWriter), fullContext)
-            CoreExtensions.locationProviderFactory -> DefaultLocationProviderFactory
+            CoreExtensions.renderer -> renderer.get(fullContext)
+            CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
             CoreExtensions.outputWriter ->  FileWriter(fullContext.configuration.outputDir, "")
             CoreExtensions.fileExtension -> ".html"
             else -> null
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index f2c99d95..0d110f85 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -11,15 +11,12 @@ import kotlin.reflect.KClass
 import kotlin.reflect.full.createInstance
 
 
-interface DokkaExtensionHandler {
+interface DokkaContext {
+    fun <T : DokkaPlugin> plugin(kclass: KClass<T>): T?
+
     operator fun <T, E> get(point: E, askDefault: AskDefault = AskDefault.WhenEmpty): List<T>
             where T : Any, E : ExtensionPoint<T>
 
-}
-
-interface DokkaContext : DokkaExtensionHandler {
-    fun <T : DokkaPlugin> plugin(kclass: KClass<T>): T?
-
     val logger: DokkaLogger
     val configuration: DokkaConfiguration
     val platforms: Map<PlatformData, EnvironmentAndFacade>
diff --git a/core/src/main/kotlin/plugability/LazyEvaluated.kt b/core/src/main/kotlin/plugability/LazyEvaluated.kt
index 79ac0968..c0c271f4 100644
--- a/core/src/main/kotlin/plugability/LazyEvaluated.kt
+++ b/core/src/main/kotlin/plugability/LazyEvaluated.kt
@@ -3,7 +3,7 @@ package org.jetbrains.dokka.plugability
 internal class LazyEvaluated<T : Any> private constructor(private val recipe: ((DokkaContext) -> T)? = null, private var value: T? = null) {
 
     internal fun get(context: DokkaContext): T {
-        if(value != null) {
+        if(value == null) {
             value = recipe?.invoke(context)
         }
         return value ?: throw AssertionError("Incorrect initialized LazyEvaluated instance")
diff --git a/core/src/main/kotlin/renderers/DefaultRenderer.kt b/core/src/main/kotlin/renderers/DefaultRenderer.kt
index 5f982251..1152bcc5 100644
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/core/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -95,7 +95,7 @@ abstract class DefaultRenderer<T>(
                 }
 
     override fun render(root: PageNode) {
-        locationProvider = context.single(CoreExtensions.locationProviderFactory).getLocationProvider(root, context)
+        locationProvider = context.single(CoreExtensions.locationProviderFactory).getLocationProvider(root as ModulePageNode)
         renderPackageList(root)
         buildSupportFiles()
         renderPages(root)
diff --git a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
index 7eae26ca..d7089f96 100644
--- a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
+++ b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
@@ -10,9 +10,9 @@ import org.jetbrains.dokka.plugability.single
 
 open class DefaultLocationProvider(
     private val pageGraphRoot: ModulePageNode,
-    private val context: DokkaContext
+    private val dokkaContext: DokkaContext
 ) : LocationProvider { // TODO: cache
-    private val extension = context.single(CoreExtensions.fileExtension)
+    private val extension = dokkaContext.single(CoreExtensions.fileExtension)
 
     override fun resolve(node: PageNode, context: PageNode?): String = pathTo(node, context) + extension
 
@@ -20,7 +20,7 @@ open class DefaultLocationProvider(
         findInPageGraph(dri, platforms)?.let { resolve(it, context) } ?:
         // Not found in PageGraph, that means it's an external link
         ExternalLocationProvider.getLocation(dri,
-            this@DefaultLocationProvider.context.configuration.passesConfigurations
+            this.dokkaContext.configuration.passesConfigurations
                 .filter { passConfig ->
                     platforms.toSet().contains(PlatformData(passConfig.moduleName, passConfig.analysisPlatform, passConfig.targets))
                 } // TODO: change targets to something better?
diff --git a/core/src/main/kotlin/resolvers/LocationProviderFactory.kt b/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
index 1622045b..c657846a 100644
--- a/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
+++ b/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
@@ -1,13 +1,13 @@
 package org.jetbrains.dokka.resolvers
 
 import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface LocationProviderFactory {
-    fun getLocationProvider(pageNode: PageNode, context: DokkaContext): LocationProvider
+    fun getLocationProvider(pageNode: ModulePageNode): LocationProvider
 }
 
-object DefaultLocationProviderFactory : LocationProviderFactory {
-    override fun getLocationProvider(pageNode: PageNode, context: DokkaContext)  = DefaultLocationProvider(pageNode as ModulePageNode, context)
+class DefaultLocationProviderFactory(val context: DokkaContext) : LocationProviderFactory {
+
+    override fun getLocationProvider(pageNode: ModulePageNode)  = DefaultLocationProvider(pageNode, context)
 }
\ No newline at end of file
-- 
cgit 


From 172c7ab00771e3a447ea03c3a81d589eb932c3fb Mon Sep 17 00:00:00 2001
From: Błażej Kardyś <bkardys@virtuslab.com>
Date: Mon, 20 Jan 2020 19:30:36 +0100
Subject: Adding java files psi parsing

---
 core/src/main/kotlin/CoreExtensions.kt             |   2 +
 core/src/main/kotlin/DokkaGenerator.kt             |  30 +-
 core/src/main/kotlin/Java/JavadocParser.kt         | 373 +++++++++++++++++++++
 core/src/main/kotlin/links/DRI.kt                  |   5 +
 core/src/main/kotlin/model/Documentable.kt         |   2 +-
 core/src/main/kotlin/pages/PageContentBuilder.kt   |   2 +-
 .../main/kotlin/plugability/DefaultExtensions.kt   |   2 +
 .../psi/DefaultPsiToDocumentationTranslator.kt     | 166 +++++++++
 .../psi/PsiToDocumentationTranslator.kt            |  14 +
 9 files changed, 593 insertions(+), 3 deletions(-)
 create mode 100644 core/src/main/kotlin/Java/JavadocParser.kt
 create mode 100644 core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
 create mode 100644 core/src/main/kotlin/transformers/psi/PsiToDocumentationTranslator.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index c1871118..46b241a7 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -10,6 +10,7 @@ import org.jetbrains.dokka.transformers.documentation.DocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeTransformer
 import org.jetbrains.dokka.transformers.documentation.DocumentationToPageTranslator
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
+import org.jetbrains.dokka.transformers.psi.PsiToDocumentationTranslator
 import kotlin.reflect.KProperty
 
 
@@ -19,6 +20,7 @@ import kotlin.reflect.KProperty
  */
 object CoreExtensions {
     val descriptorToDocumentationTranslator by coreExtension<DescriptorToDocumentationTranslator>()
+    val psiToDocumentationTranslator by coreExtension<PsiToDocumentationTranslator>()
     val documentationMerger by coreExtension<DocumentationNodeMerger>()
     val documentationTransformer by coreExtension<DocumentationNodeTransformer>()
     val commentsToContentConverter by coreExtension<CommentsToContentConverter>()
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 036cbfda..350ee5df 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,5 +1,8 @@
 package org.jetbrains.dokka
 
+import com.intellij.openapi.vfs.VirtualFileManager
+import com.intellij.psi.PsiJavaFile
+import com.intellij.psi.PsiManager
 import org.jetbrains.dokka.analysis.AnalysisEnvironment
 import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.model.Module
@@ -8,11 +11,13 @@ import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 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.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 
@@ -64,7 +69,8 @@ class DokkaGenerator(
     fun createDocumentationModels(
         platforms: Map<PlatformData, EnvironmentAndFacade>,
         context: DokkaContext
-    ) = platforms.map { (pdata, _) -> translateDescriptors(pdata, context) }
+    ) = platforms.map { (pdata, _) -> translateDescriptors(pdata, context) } +
+            platforms.map { (pdata, _)  -> translatePsi(pdata, context) }
 
     fun mergeDocumentationModels(
         modulesFromPlatforms: List<Module>,
@@ -123,6 +129,28 @@ class DokkaGenerator(
             .invoke(platformData.name, packageFragments, platformData, context)
     }
 
+    private fun translatePsi(platformData: PlatformData, context: DokkaContext): Module {
+        val (environment, _) = context.platforms.getValue(platformData)
+
+        val sourceRoots = environment.configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
+            ?.filterIsInstance<JavaSourceRoot>()
+            ?.map { it.file }
+                ?: listOf()
+        val localFileSystem = VirtualFileManager.getInstance().getFileSystem("file")
+
+        val psiFiles = sourceRoots.map { sourceRoot ->
+            sourceRoot.absoluteFile.walkTopDown().mapNotNull {
+                localFileSystem.findFileByPath(it.path)?.let { vFile ->
+                    PsiManager.getInstance(environment.project).findFile(vFile) as? PsiJavaFile
+                }
+            }.toList()
+        }.flatten()
+
+        return context.single(CoreExtensions.psiToDocumentationTranslator)
+            .invoke(psiFiles, platformData, context)
+
+    }
+
     private class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
         override fun clear() {
             seenErrors = false
diff --git a/core/src/main/kotlin/Java/JavadocParser.kt b/core/src/main/kotlin/Java/JavadocParser.kt
new file mode 100644
index 00000000..5058634a
--- /dev/null
+++ b/core/src/main/kotlin/Java/JavadocParser.kt
@@ -0,0 +1,373 @@
+package org.jetbrains.dokka
+
+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
+}
+
+class JavadocParser(
+    private val logger: DokkaLogger
+) : JavaDocumentationParser {
+
+    override fun parseDocumentation(element: PsiNamedElement): DocumentationNode {
+        val docComment = (element as? PsiDocCommentOwner)?.docComment ?: return DocumentationNode(emptyList())
+        val nodes =
+            convertJavadocElements(docComment.descriptionElements.dropWhile { it.text.trim().isEmpty() }, element)
+        return DocumentationNode(nodes.map { Description(it) })
+        /*val firstParagraphContents = nodes.takeWhile { it !is ContentParagraph }
+        val firstParagraph = ContentParagraph()
+        if (firstParagraphContents.isNotEmpty()) {
+            firstParagraphContents.forEach { firstParagraph.append(it) }
+            result.add(firstParagraph)
+        }
+
+        result.appendAll(nodes.drop(firstParagraphContents.size))
+
+        if (element is PsiMethod) {
+            val tagsByName = element.searchInheritedTags()
+            for ((tagName, tags) in tagsByName) {
+                for ((tag, context) in tags) {
+                    val section = result.addSection(javadocSectionDisplayName(tagName), tag.getSubjectName())
+                    val signature = signatureProvider.signature(element)
+                    when (tagName) {
+                        "param" -> {
+                            section.appendTypeElement(signature) {
+                                it.details
+                                    .find { node -> node.kind == NodeKind.Parameter && node.name == tag.getSubjectName() }
+                                    ?.detailOrNull(NodeKind.Type)
+                            }
+                        }
+                        "return" -> {
+                            section.appendTypeElement(signature) { it.detailOrNull(NodeKind.Type) }
+                        }
+                    }
+                    section.appendAll(convertJavadocElements(tag.contentElements(), context))
+                }
+            }
+        }
+
+        docComment.tags.forEach { tag ->
+            when (tag.name) {
+                "see" -> result.convertSeeTag(tag)
+                "deprecated" -> {
+                    deprecatedContent = Content().apply {
+                        appendAll(convertJavadocElements(tag.contentElements(), element))
+                    }
+                }
+                in tagsToInherit -> {}
+                else -> {
+                    val subjectName = tag.getSubjectName()
+                    val section = result.addSection(javadocSectionDisplayName(tag.name), subjectName)
+
+                    section.appendAll(convertJavadocElements(tag.contentElements(), element))
+                }
+            }
+        }
+        return JavadocParseResult(result, deprecatedContent)*/
+    }
+
+    private val tagsToInherit = setOf("param", "return", "throws")
+
+    private data class TagWithContext(val tag: PsiDocTag, val context: PsiNamedElement)
+/*
+    private fun PsiMethod.searchInheritedTags(): Map<String, Collection<TagWithContext>> {
+
+        val output = tagsToInherit.keysToMap { mutableMapOf<String?, TagWithContext>() }
+
+        fun recursiveSearch(methods: Array<PsiMethod>) {
+            for (method in methods) {
+                recursiveSearch(method.findSuperMethods())
+            }
+            for (method in methods) {
+                for (tag in method.docComment?.tags.orEmpty()) {
+                    if (tag.name in tagsToInherit) {
+                        output[tag.name]!![tag.getSubjectName()] = TagWithContext(tag, method)
+                    }
+                }
+            }
+        }
+
+        recursiveSearch(arrayOf(this))
+        return output.mapValues { it.value.values }
+    }
+*/
+
+    private fun PsiDocTag.contentElements(): Iterable<PsiElement> {
+        val tagValueElements = children
+            .dropWhile { it.node?.elementType == JavaDocTokenType.DOC_TAG_NAME }
+            .dropWhile { it is PsiWhiteSpace }
+            .filterNot { it.node?.elementType == JavaDocTokenType.DOC_COMMENT_LEADING_ASTERISKS }
+        return if (getSubjectName() != null) tagValueElements.dropWhile { it is PsiDocTagValue } else tagValueElements
+    }
+
+    private fun convertJavadocElements(elements: Iterable<PsiElement>, element: PsiNamedElement): List<DocTag> {
+        val doc = Jsoup.parse(expandAllForElements(elements, element))
+        return doc.body().childNodes().mapNotNull { convertHtmlNode(it) }
+    }
+
+    private fun expandAllForElements(elements: Iterable<PsiElement>, element: PsiNamedElement): String {
+        val htmlBuilder = StringBuilder()
+        elements.forEach {
+            if (it is PsiInlineDocTag) {
+                htmlBuilder.append(convertInlineDocTag(it, element))
+            } else {
+                htmlBuilder.append(it.text)
+            }
+        }
+        return htmlBuilder.toString().trim()
+    }
+
+    private fun convertHtmlNode(node: Node, insidePre: Boolean = false): DocTag? = when (node) {
+        is TextNode -> Text(body = if (insidePre) node.wholeText else node.text())
+        is Element -> createBlock(node)
+        else -> null
+    }
+
+    private fun createBlock(element: Element): DocTag {
+        val children = element.childNodes().mapNotNull { convertHtmlNode(it) }
+        return when (element.tagName()) {
+            "p" -> P(children)
+            "b" -> B(children)
+            "strong" -> Strong(children)
+            "i" -> I(children)
+            "em" -> Em(children)
+//            "s", "del" -> ContentStrikethrough()
+            "code" -> Code(children)
+            "pre" -> Pre(children)
+            "ul" -> Ul(children)
+            "ol" -> Ol(children)
+            "li" -> Li(children)
+//            "a" -> createLink(element)
+//            "br" -> ContentBlock().apply { hardLineBreak() }
+            else -> Text(body = element.ownText())
+        }
+    }
+/*
+
+    private fun createLink(element: Element): DocTag {
+        return when {
+            element.hasAttr("docref") -> {
+                val docref = element.attr("docref")
+                ContentNodeLazyLink(docref) { refGraph.lookupOrWarn(docref, logger) }
+            }
+            element.hasAttr("href") -> {
+                val href = element.attr("href")
+
+                val uri = try {
+                    URI(href)
+                } catch (_: Exception) {
+                    null
+                }
+
+                if (uri?.isAbsolute == false) {
+                    ContentLocalLink(href)
+                } else {
+                    ContentExternalLink(href)
+                }
+            }
+            element.hasAttr("name") -> {
+                ContentBookmark(element.attr("name"))
+            }
+            else -> ContentBlock()
+        }
+    }
+
+
+    private fun convertSeeTag(tag: PsiDocTag) {
+        val linkElement = tag.linkElement() ?: return
+        val seeSection = findSectionByTag(ContentTags.SeeAlso) ?: addSection(ContentTags.SeeAlso, null)
+
+        val valueElement = tag.referenceElement()
+        val externalLink = resolveExternalLink(valueElement)
+        val text = ContentText(linkElement.text)
+
+        val linkSignature by lazy { resolveInternalLink(valueElement) }
+        val node = when {
+            externalLink != null -> {
+                val linkNode = ContentExternalLink(externalLink)
+                linkNode.append(text)
+                linkNode
+            }
+            linkSignature != null -> {
+                val linkNode =
+                        ContentNodeLazyLink(
+                                (tag.valueElement ?: linkElement).text
+                        ) { refGraph.lookupOrWarn(linkSignature!!, logger) }
+                linkNode.append(text)
+                linkNode
+            }
+            else -> text
+        }
+        seeSection.append(node)
+    }
+*/
+    private fun convertInlineDocTag(tag: PsiInlineDocTag, element: PsiNamedElement) = when (tag.name) {
+        "link", "linkplain" -> {
+            val valueElement = tag.referenceElement()
+            val externalLink = resolveExternalLink(valueElement)
+            val linkSignature by lazy { resolveInternalLink(valueElement) }
+            if (externalLink != null || linkSignature != null) {
+                val labelText = tag.dataElements.firstOrNull { it is PsiDocToken }?.text ?: valueElement!!.text
+                val linkTarget = if (externalLink != null) "href=\"$externalLink\"" else "docref=\"$linkSignature\""
+                val link = "<a $linkTarget>$labelText</a>"
+                if (tag.name == "link") "<code>$link</code>" else link
+            } else if (valueElement != null) {
+                valueElement.text
+            } else {
+                ""
+            }
+        }
+        "code", "literal" -> {
+            val text = StringBuilder()
+            tag.dataElements.forEach { text.append(it.text) }
+            val escaped = text.toString().trimStart()
+            if (tag.name == "code") "<code>$escaped</code>" else escaped
+        }
+        "inheritDoc" -> {
+            val result = (element as? PsiMethod)?.let {
+                // @{inheritDoc} is only allowed on functions
+                val parent = tag.parent
+                when (parent) {
+                    is PsiDocComment -> element.findSuperDocCommentOrWarn()
+                    is PsiDocTag -> element.findSuperDocTagOrWarn(parent)
+                    else -> null
+                }
+            }
+            result ?: tag.text
+        }
+        else -> tag.text
+    }
+
+    private fun PsiDocTag.referenceElement(): PsiElement? =
+        linkElement()?.let {
+            if (it.node.elementType == JavaDocElementType.DOC_REFERENCE_HOLDER) {
+                PsiTreeUtil.findChildOfType(it, PsiJavaCodeReferenceElement::class.java)
+            } else {
+                it
+            }
+        }
+
+    private fun PsiDocTag.linkElement(): PsiElement? =
+        valueElement ?: dataElements.firstOrNull { it !is PsiWhiteSpace }
+
+    private fun resolveExternalLink(valueElement: PsiElement?): String? {
+        /*val target = valueElement?.reference?.resolve()
+        if (target != null) {
+            return externalDocumentationLinkResolver.buildExternalDocumentationLink(target)
+        }*/
+        return null
+    }
+
+    private fun resolveInternalLink(valueElement: PsiElement?): String? {
+        /*val target = valueElement?.reference?.resolve()
+        if (target != null) {
+            return signatureProvider.signature(target)
+        }*/
+        return null
+    }
+
+    fun PsiDocTag.getSubjectName(): String? {
+        if (name == "param" || name == "throws" || name == "exception") {
+            return valueElement?.text
+        }
+        return null
+    }
+
+    private fun PsiMethod.findSuperDocCommentOrWarn(): String {
+        val method = findFirstSuperMethodWithDocumentation(this)
+        if (method != null) {
+            val descriptionElements = method.docComment?.descriptionElements?.dropWhile {
+                it.text.trim().isEmpty()
+            } ?: return ""
+
+            return expandAllForElements(descriptionElements, method)
+        }
+        logger.warn("No docs found on supertype with {@inheritDoc} method ${this.name} in ${this.containingFile.name}}")
+        return ""
+    }
+
+
+    private fun PsiMethod.findSuperDocTagOrWarn(elementToExpand: PsiDocTag): String {
+        val result = findFirstSuperMethodWithDocumentationforTag(elementToExpand, this)
+
+        if (result != null) {
+            val (method, tag) = result
+
+            val contentElements = tag.contentElements().dropWhile { it.text.trim().isEmpty() }
+
+            val expandedString = expandAllForElements(contentElements, method)
+
+            return expandedString
+        }
+        logger.warn("No docs found on supertype for @${elementToExpand.name} ${elementToExpand.getSubjectName()} with {@inheritDoc} method ${this.name} in ${this.containingFile.name}}")
+        return ""
+    }
+
+    private fun findFirstSuperMethodWithDocumentation(current: PsiMethod): PsiMethod? {
+        val superMethods = current.findSuperMethods()
+        for (method in superMethods) {
+            val docs = method.docComment?.descriptionElements?.dropWhile { it.text.trim().isEmpty() }
+            if (!docs.isNullOrEmpty()) {
+                return method
+            }
+        }
+        for (method in superMethods) {
+            val result = findFirstSuperMethodWithDocumentation(method)
+            if (result != null) {
+                return result
+            }
+        }
+
+        return null
+    }
+
+    private fun findFirstSuperMethodWithDocumentationforTag(elementToExpand: PsiDocTag, current: PsiMethod): Pair<PsiMethod, PsiDocTag>? {
+        val superMethods = current.findSuperMethods()
+        val mappedFilteredTags = superMethods.map {
+            it to it.docComment?.tags?.filter { it.name == elementToExpand.name }
+        }
+
+        for ((method, tags) in mappedFilteredTags) {
+            tags ?: continue
+            for (tag in tags) {
+                val (tagSubject, elementSubject) = when (tag.name) {
+                    "throws" -> {
+                        // match class names only for throws, ignore possibly fully qualified path
+                        // TODO: Always match exactly here
+                        tag.getSubjectName()?.split(".")?.last() to elementToExpand.getSubjectName()?.split(".")?.last()
+                    }
+                    else -> {
+                        tag.getSubjectName() to elementToExpand.getSubjectName()
+                    }
+                }
+
+                if (tagSubject == elementSubject) {
+                    return method to tag
+                }
+            }
+        }
+
+        for (method in superMethods) {
+            val result = findFirstSuperMethodWithDocumentationforTag(elementToExpand, method)
+            if (result != null) {
+                return result
+            }
+        }
+        return null
+    }
+
+}
diff --git a/core/src/main/kotlin/links/DRI.kt b/core/src/main/kotlin/links/DRI.kt
index 0fe2900b..404813fa 100644
--- a/core/src/main/kotlin/links/DRI.kt
+++ b/core/src/main/kotlin/links/DRI.kt
@@ -110,6 +110,11 @@ sealed class TypeReference {
     }
 }
 
+data class JavaClassReference(val name: String): TypeReference() {
+    override val isNullable = true
+    override fun toString(): String = name
+}
+
 data class TypeParam(val bounds: List<TypeReference>, override val isNullable: Boolean) : TypeReference()
 
 data class TypeConstructor(
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index ac0b41d9..3f50667a 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -152,7 +152,7 @@ private fun String.shorten(maxLength: Int) = lineSequence().first().let {
 interface TypeWrapper {
     val constructorFqName: String?
     val constructorNamePathSegments: List<String>
-    val arguments: List<KotlinTypeWrapper>
+    val arguments: List<TypeWrapper>
     val dri: DRI?
 }
 interface ClassKind
diff --git a/core/src/main/kotlin/pages/PageContentBuilder.kt b/core/src/main/kotlin/pages/PageContentBuilder.kt
index cc53586e..25ddc2f1 100644
--- a/core/src/main/kotlin/pages/PageContentBuilder.kt
+++ b/core/src/main/kotlin/pages/PageContentBuilder.kt
@@ -168,7 +168,7 @@ private fun PageContentBuilder.type(t: TypeWrapper) {
         link(t.constructorNamePathSegments.last(), t.dri!!)
     else (this as? DefaultPageContentBuilder)?.let {
             logger.error("type $t cannot be resolved")
-            text("???")
+            text(t.toString())
         }
     list(t.arguments, prefix = "<", suffix = ">") {
         type(it)
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index b3ff4248..91ab9cb8 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -8,6 +8,7 @@ import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
+import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
 
 internal object DefaultExtensions {
 
@@ -20,6 +21,7 @@ internal object DefaultExtensions {
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
             CoreExtensions.descriptorToDocumentationTranslator ->  DefaultDescriptorToDocumentationTranslator
+            CoreExtensions.psiToDocumentationTranslator -> DefaultPsiToDocumentationTranslator
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
             CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
diff --git a/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
new file mode 100644
index 00000000..d3ad4526
--- /dev/null
+++ b/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
@@ -0,0 +1,166 @@
+package org.jetbrains.dokka.transformers.psi
+
+import com.intellij.psi.*
+import com.intellij.psi.impl.source.PsiClassReferenceType
+import org.jetbrains.dokka.JavadocParser
+import org.jetbrains.dokka.links.*
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.utilities.DokkaLogger
+
+object DefaultPsiToDocumentationTranslator : PsiToDocumentationTranslator {
+
+    override fun invoke(
+        psiFiles: List<PsiJavaFile>,
+        platformData: PlatformData,
+        context: DokkaContext
+    ): Module {
+        val docParser = DokkaPsiParser(platformData, context.logger)
+        return Module( "JavaModule",
+            psiFiles.map { psiFile ->
+                val dri = DRI(packageName = psiFile.packageName)
+                Package(
+                    dri,
+                    emptyList(),
+                    emptyList(),
+                    psiFile.classes.map { docParser.parseClass(it, dri) }
+                )
+            }
+        )
+    }
+
+    class DokkaPsiParser(
+        private val platformData: PlatformData,
+        logger: DokkaLogger
+    ) {
+
+        private val javadocParser: JavadocParser = JavadocParser(logger)
+
+        private fun getComment(psi: PsiNamedElement): List<PlatformInfo> {
+            val comment = javadocParser.parseDocumentation(psi)
+            return listOf(BasePlatformInfo(comment, listOf(platformData)))
+        }
+
+        fun parseClass(psi: PsiClass, parent: DRI): Class = with(psi) {
+            val kind = when {
+                isAnnotationType -> JavaClassKindTypes.ANNOTATION_CLASS
+                isInterface -> JavaClassKindTypes.INTERFACE
+                isEnum -> JavaClassKindTypes.ENUM_CLASS
+                else -> JavaClassKindTypes.CLASS
+            }
+            val dri = parent.withClass(name.toString())
+            /*superTypes.filter { !ignoreSupertype(it) }.forEach {
+            node.appendType(it, NodeKind.Supertype)
+            val superClass = it.resolve()
+            if (superClass != null) {
+                link(superClass, node, RefKind.Inheritor)
+            }
+        }*/
+            return Class(
+                dri,
+                name.orEmpty(),
+                kind,
+                constructors.map { parseFunction(it, dri, true) },
+                methods.mapNotNull { if (!it.isConstructor) parseFunction(it, dri) else null },
+                fields.mapNotNull { parseField(it, dri) },
+                innerClasses.map { parseClass(it, dri) },
+                null,
+                emptyList(),
+                mutableSetOf()
+            )
+        }
+
+        private fun parseFunction(psi: PsiMethod, parent: DRI, isConstructor: Boolean = false): Function {
+            val dri = parent.copy(callable = Callable(
+                psi.name,
+                JavaClassReference(psi.containingClass?.name.orEmpty()),
+                psi.parameterList.parameters.map { parameter ->
+                    JavaClassReference(parameter.type.canonicalText)
+                }
+            )
+            )
+            return Function(
+                dri,
+                if (isConstructor) "<init>" else psi.name,
+                psi.returnType?.let { JavaTypeWrapper(type = it) },
+                isConstructor,
+                null,
+                psi.parameterList.parameters.mapIndexed { index, psiParameter ->
+                    Parameter(
+                        dri.copy(target = index + 1),
+                        psiParameter.name,
+                        JavaTypeWrapper(psiParameter.type),
+                        getComment(psi)
+                    )
+                },
+                null,
+                getComment(psi)
+            )
+        }
+
+        private fun parseField(psi: PsiField, parent: DRI): Property {
+            val dri = parent.copy(
+                callable = Callable(
+                    psi.name,
+                    JavaClassReference(psi.containingClass?.name.orEmpty()),
+                    emptyList()
+                )
+            )
+            return Property(
+                dri,
+                psi.name,
+                null,
+                null,
+                getComment(psi)
+            )
+        }
+    }
+}
+
+enum class JavaClassKindTypes : ClassKind {
+    CLASS,
+    INTERFACE,
+    ENUM_CLASS,
+    ENUM_ENTRY,
+    ANNOTATION_CLASS;
+}
+
+class JavaTypeWrapper(
+    type: PsiType
+) : TypeWrapper {
+
+    override val constructorFqName: String?
+    override val constructorNamePathSegments: List<String>
+    override val arguments: List<JavaTypeWrapper>
+    override val dri: DRI?
+
+    init {
+        if (type is PsiClassReferenceType) {
+            val resolved = type.resolve()
+            constructorFqName = resolved?.qualifiedName
+            constructorNamePathSegments = resolved?.qualifiedName?.split('.') ?: emptyList()
+            arguments = type.parameters.mapNotNull {
+                if (it is PsiClassReferenceType) JavaTypeWrapper(it) else null
+            }
+            dri = fromPsi(type)
+        } else {
+            type as PsiPrimitiveType
+            constructorFqName = type.name
+            constructorNamePathSegments = type.name.split('.')
+            arguments = emptyList()
+            dri = null
+        }
+    }
+
+    private fun fromPsi(type: PsiClassReferenceType): DRI {
+        val className = type.className
+        val pkg = type.canonicalText.removeSuffix(className).removeSuffix(".")
+        return DRI(packageName = pkg, classNames = className)
+    }
+
+    override fun toString(): String {
+        return constructorFqName.orEmpty()
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/psi/PsiToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/psi/PsiToDocumentationTranslator.kt
new file mode 100644
index 00000000..5a1209b1
--- /dev/null
+++ b/core/src/main/kotlin/transformers/psi/PsiToDocumentationTranslator.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.dokka.transformers.psi
+
+import com.intellij.psi.PsiJavaFile
+import org.jetbrains.dokka.model.Module
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface PsiToDocumentationTranslator {
+    fun invoke(
+        psiFiles: List<PsiJavaFile>,
+        platformData: PlatformData,
+        context: DokkaContext
+    ): Module
+}
-- 
cgit 


From 3a13b81f2aebc255bec5e48b276c86b2d4ee16a2 Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Fri, 31 Jan 2020 10:49:25 +0100
Subject: Handles errors and fixes minor bugs

---
 core/src/main/kotlin/DokkaGenerator.kt                |  2 +-
 core/src/main/kotlin/plugability/DefaultExtensions.kt |  2 +-
 core/src/main/kotlin/renderers/FileWriter.kt          | 12 +++++++-----
 core/src/main/kotlin/utilities/DokkaLogging.kt        | 11 ++++++++---
 4 files changed, 17 insertions(+), 10 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index add7eedb..138bd70d 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -163,7 +163,7 @@ class DokkaGenerator(
             if (severity == CompilerMessageSeverity.ERROR) {
                 seenErrors = true
             }
-            logger.error(MessageRenderer.PLAIN_FULL_PATHS.render(severity, message, location))
+            logger.info(MessageRenderer.PLAIN_FULL_PATHS.render(severity, message, location))
         }
 
         override fun hasErrors() = seenErrors
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 91ab9cb8..e4a47ee1 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -27,7 +27,7 @@ internal object DefaultExtensions {
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
             CoreExtensions.renderer -> renderer.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
-            CoreExtensions.outputWriter ->  FileWriter(fullContext.configuration.outputDir, "")
+            CoreExtensions.outputWriter ->  FileWriter(fullContext, "")
             CoreExtensions.fileExtension -> ".html"
             else -> null
         }.let { listOfNotNull( it ) as List<T> }
diff --git a/core/src/main/kotlin/renderers/FileWriter.kt b/core/src/main/kotlin/renderers/FileWriter.kt
index 996fadc8..3cb3b5b5 100644
--- a/core/src/main/kotlin/renderers/FileWriter.kt
+++ b/core/src/main/kotlin/renderers/FileWriter.kt
@@ -1,27 +1,29 @@
 package org.jetbrains.dokka.renderers
 
+import org.jetbrains.dokka.plugability.DokkaContext
 import java.io.File
 import java.io.IOException
 import java.net.URI
 import java.nio.file.*
 
-class FileWriter(val root: String, override val extension: String) : OutputWriter {
+class FileWriter(val context: DokkaContext, override val extension: String): OutputWriter {
     private val createdFiles: MutableSet<String> = mutableSetOf()
     private val jarUriPrefix = "jar:file:"
-
+    private val root = context.configuration.outputDir
     override fun write(path: String, text: String, ext: String) {
         if (createdFiles.contains(path)) {
-            println("ERROR. An attempt to write $root/$path several times!")
+            context.logger.error("An attempt to write ${root}/$path several times!")
             return
         }
         createdFiles.add(path)
 
         try {
+//          println("Writing $root/$path$ext")
             val dir = Paths.get(root, path.dropLastWhile { it != '/' }).toFile()
             dir.mkdirsOrFail()
             Files.write(Paths.get(root, "$path$ext"), text.lines())
-        } catch (e: Throwable) {
-            println("Failed to write $this. ${e.message}")
+        } catch (e : Throwable) {
+            context.logger.error("Failed to write $this. ${e.message}")
             e.printStackTrace()
         }
     }
diff --git a/core/src/main/kotlin/utilities/DokkaLogging.kt b/core/src/main/kotlin/utilities/DokkaLogging.kt
index 6eb7867b..9fe15d59 100644
--- a/core/src/main/kotlin/utilities/DokkaLogging.kt
+++ b/core/src/main/kotlin/utilities/DokkaLogging.kt
@@ -10,6 +10,7 @@ interface DokkaLogger {
 
 object DokkaConsoleLogger : DokkaLogger {
     var warningCount: Int = 0
+    var errorCount: Int = 0
 
     override fun debug(message: String)= println(message)
 
@@ -19,11 +20,15 @@ object DokkaConsoleLogger : DokkaLogger {
 
     override fun warn(message: String) = println("WARN: $message").also { warningCount++ }
 
-    override fun error(message: String) = println("ERROR: $message")
+    override fun error(message: String) = println("ERROR: $message").also { errorCount++ }
 
     fun report() {
-        if (warningCount > 0) {
-            println("generation completed with $warningCount warnings")
+        if (warningCount > 0 || errorCount > 0) {
+            println("generation completed with $warningCount warning" +
+                    (if(warningCount == 1) "" else "s") +
+                    " and $errorCount error" +
+                    if(errorCount == 1) "" else "s"
+            )
         } else {
             println("generation completed successfully")
         }
-- 
cgit 


From 582f5f89557e943169c10a4fc3d58d99528d8e86 Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Mon, 3 Feb 2020 15:57:29 +0100
Subject: Adds summary reporting for all logging runners

---
 core/src/main/kotlin/DokkaBootstrapImpl.kt         | 20 +++++++++++++++++--
 core/src/main/kotlin/DokkaGenerator.kt             |  2 ++
 .../main/kotlin/plugability/DefaultExtensions.kt   |  2 +-
 core/src/main/kotlin/utilities/DokkaLogging.kt     | 23 ++++++++++++----------
 runners/ant/src/main/kotlin/ant/dokka.kt           | 18 +++++++++++++++--
 runners/cli/src/main/kotlin/cli/main.kt            |  6 +++---
 6 files changed, 53 insertions(+), 18 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index ccd87363..fc1b6926 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -2,6 +2,7 @@ package org.jetbrains.dokka
 
 import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaConfiguration.PackageOptions
+import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import org.jetbrains.dokka.utilities.DokkaLogger
 
 import java.util.function.BiConsumer
@@ -26,6 +27,9 @@ fun parsePerPackageOptions(arg: String): List<PackageOptions> {
 class DokkaBootstrapImpl : DokkaBootstrap {
 
     private class DokkaProxyLogger(val consumer: BiConsumer<String, String>) : DokkaLogger {
+        override var warningsCount: Int = 0
+        override var errorsCount: Int = 0
+
         override fun debug(message: String) {
             consumer.accept("debug", message)
         }
@@ -39,11 +43,23 @@ class DokkaBootstrapImpl : DokkaBootstrap {
         }
 
         override fun warn(message: String) {
-            consumer.accept("warn", message)
+            consumer.accept("warn", message).also { warningsCount++ }
         }
 
         override fun error(message: String) {
-            consumer.accept("error", message)
+            consumer.accept("error", message).also { errorsCount++ }
+        }
+
+        override fun report() {
+            if (warningsCount > 0 || errorsCount > 0) {
+                println("Generation completed with $warningsCount warning" +
+                        (if(DokkaConsoleLogger.warningsCount == 1) "" else "s") +
+                        " and $errorsCount error" +
+                        if(DokkaConsoleLogger.errorsCount == 1) "" else "s"
+                )
+            } else {
+                println("generation completed successfully")
+            }
         }
     }
 
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 138bd70d..fef71aab 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -54,6 +54,8 @@ class DokkaGenerator(
 
         logger.progress("Rendering")
         render(transformedPages, context)
+
+        logger.report()
     }
 
     fun setUpAnalysis(configuration: DokkaConfiguration): Map<PlatformData, EnvironmentAndFacade> =
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index e4a47ee1..c45f28be 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -13,7 +13,7 @@ import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
 internal object DefaultExtensions {
 
     private val renderer: LazyEvaluated<HtmlRenderer> = LazyEvaluated.fromRecipe { HtmlRenderer(it.single(CoreExtensions.outputWriter), it) }
-    private val converter: LazyEvaluated<DocTagToContentConverter> = LazyEvaluated.fromRecipe {DocTagToContentConverter(it) }
+    private val converter: LazyEvaluated<DocTagToContentConverter> = LazyEvaluated.fromRecipe { DocTagToContentConverter(it) }
     private val providerFactory: LazyEvaluated<DefaultLocationProviderFactory> = LazyEvaluated.fromRecipe { DefaultLocationProviderFactory(it) }
 
 
diff --git a/core/src/main/kotlin/utilities/DokkaLogging.kt b/core/src/main/kotlin/utilities/DokkaLogging.kt
index 9fe15d59..1c05c95d 100644
--- a/core/src/main/kotlin/utilities/DokkaLogging.kt
+++ b/core/src/main/kotlin/utilities/DokkaLogging.kt
@@ -1,16 +1,19 @@
 package org.jetbrains.dokka.utilities
 
 interface DokkaLogger {
+    var warningsCount: Int
+    var errorsCount: Int
     fun debug(message: String)
     fun info(message: String)
     fun progress(message: String)
     fun warn(message: String)
     fun error(message: String)
+    fun report()
 }
 
 object DokkaConsoleLogger : DokkaLogger {
-    var warningCount: Int = 0
-    var errorCount: Int = 0
+    override var warningsCount: Int = 0
+    override var errorsCount: Int = 0
 
     override fun debug(message: String)= println(message)
 
@@ -18,16 +21,16 @@ object DokkaConsoleLogger : DokkaLogger {
 
     override fun info(message: String) = println(message)
 
-    override fun warn(message: String) = println("WARN: $message").also { warningCount++ }
+    override fun warn(message: String) = println("WARN: $message").also { warningsCount++ }
 
-    override fun error(message: String) = println("ERROR: $message").also { errorCount++ }
+    override fun error(message: String) = println("ERROR: $message").also { errorsCount++ }
 
-    fun report() {
-        if (warningCount > 0 || errorCount > 0) {
-            println("generation completed with $warningCount warning" +
-                    (if(warningCount == 1) "" else "s") +
-                    " and $errorCount error" +
-                    if(errorCount == 1) "" else "s"
+    override fun report() {
+        if (warningsCount > 0 || errorsCount > 0) {
+            println("Generation completed with warningsCount warning" +
+                    (if(warningsCount == 1) "" else "s") +
+                    " and errorsCount error" +
+                    if(errorsCount == 1) "" else "s"
             )
         } else {
             println("generation completed successfully")
diff --git a/runners/ant/src/main/kotlin/ant/dokka.kt b/runners/ant/src/main/kotlin/ant/dokka.kt
index 1395af31..6b83fc8f 100644
--- a/runners/ant/src/main/kotlin/ant/dokka.kt
+++ b/runners/ant/src/main/kotlin/ant/dokka.kt
@@ -7,15 +7,29 @@ import org.apache.tools.ant.types.Path
 import org.apache.tools.ant.types.Reference
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
+import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import org.jetbrains.dokka.utilities.DokkaLogger
 import java.io.File
 
 class AntLogger(val task: Task): DokkaLogger {
+    override var warningsCount: Int = 0
+    override var errorsCount: Int = 0
     override fun debug(message: String) = task.log(message, Project.MSG_DEBUG)
     override fun info(message: String) = task.log(message, Project.MSG_VERBOSE)
     override fun progress(message: String) = task.log(message, Project.MSG_INFO)
-    override fun warn(message: String) = task.log(message, Project.MSG_WARN)
-    override fun error(message: String) = task.log(message, Project.MSG_ERR)
+    override fun warn(message: String) = task.log(message, Project.MSG_WARN).also { warningsCount++ }
+    override fun error(message: String) = task.log(message, Project.MSG_ERR).also { errorsCount++ }
+    override fun report() {
+        if (warningsCount > 0 || errorsCount > 0) {
+            task.log("Generation completed with $warningsCount warning" +
+                    (if(warningsCount == 1) "" else "s") +
+                    " and $errorsCount error" +
+                    if(errorsCount == 1) "" else "s"
+            )
+        } else {
+            task.log("generation completed successfully")
+        }
+    }
 }
 
 class AntSourceLinkDefinition(var path: String? = null, var url: String? = null, var lineSuffix: String? = null)
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index 2daac470..db8ddb01 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -196,9 +196,9 @@ object MainKt {
         val javaHome = System.getProperty("java.home")
         val default = File(javaHome, "../lib/tools.jar")
         val mac = File(javaHome, "../Classes/classes.jar")
-        when {
-            default.exists() -> return default
-            mac.exists() -> return mac
+        return when {
+            default.exists() -> default
+            mac.exists() -> mac
             else -> {
                 throw Exception("tools.jar not found, please check it, also you can provide it manually, using -cp")
             }
-- 
cgit 


From 216a7f6b89ce769bcf4d41301ecc34636dc20155 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Fri, 31 Jan 2020 18:16:38 +0100
Subject: Html related things moved to its own package

---
 .../main/kotlin/plugability/DefaultExtensions.kt   |   2 +-
 core/src/main/kotlin/renderers/HtmlRenderer.kt     | 216 --------------------
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt | 218 +++++++++++++++++++++
 .../kotlin/renderers/html/htmlPreprocessors.kt     |  57 ++++++
 .../src/main/kotlin/renderers/htmlPreprocessors.kt |  57 ------
 5 files changed, 276 insertions(+), 274 deletions(-)
 delete mode 100644 core/src/main/kotlin/renderers/HtmlRenderer.kt
 create mode 100644 core/src/main/kotlin/renderers/html/HtmlRenderer.kt
 create mode 100644 core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
 delete mode 100644 core/src/main/kotlin/renderers/htmlPreprocessors.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index c45f28be..9f36b2a4 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -3,7 +3,7 @@ package org.jetbrains.dokka.plugability
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.DocTagToContentConverter
 import org.jetbrains.dokka.renderers.FileWriter
-import org.jetbrains.dokka.renderers.HtmlRenderer
+import org.jetbrains.dokka.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
diff --git a/core/src/main/kotlin/renderers/HtmlRenderer.kt b/core/src/main/kotlin/renderers/HtmlRenderer.kt
deleted file mode 100644
index e8c3a486..00000000
--- a/core/src/main/kotlin/renderers/HtmlRenderer.kt
+++ /dev/null
@@ -1,216 +0,0 @@
-package org.jetbrains.dokka.renderers
-
-import kotlinx.html.*
-import kotlinx.html.stream.createHTML
-import org.jetbrains.dokka.model.Function
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.plugability.DokkaContext
-import java.io.File
-
-open class HtmlRenderer(
-    outputWriter: OutputWriter,
-    context: DokkaContext
-) : DefaultRenderer<FlowContent>(outputWriter, context) {
-
-    private val pageList = mutableListOf<String>()
-
-    private var idCounter = 0
-        get() = ++field
-
-    private fun FlowContent.buildSideMenu(context: PageNode, node: PageNode) {
-        val children = node.children.filter { it !is MemberPageNode }
-        val submenuId = if (children.isNotEmpty()) "nav$idCounter" else null
-        div("sideMenuPart") {
-            submenuId?.also { id = it }
-            div("overview") {
-                buildLink(node, context)
-                submenuId?.also {
-                    span("navButton") {
-                        onClick = """document.getElementById("$it").classList.toggle("hidden");"""
-                        span("navButtonContent")
-                    }
-                }
-            }
-            children.forEach { buildSideMenu(context, it) }
-        }
-    }
-
-    override val preprocessors = listOf(RootCreator, SearchPageInstaller, ResourceInstaller, StyleAndScriptsAppender)
-
-    override fun FlowContent.buildList(node: ContentList, pageContext: ContentPage) =
-        if (node.ordered) ol {
-            buildListItems(node.children, pageContext)
-        }
-        else ul {
-            buildListItems(node.children, pageContext)
-        }
-
-    protected open fun OL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
-        items.forEach {
-            if (it is ContentList)
-                buildList(it, pageContext)
-            else
-                li { it.build(this, pageContext) }
-        }
-    }
-
-    protected open fun UL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
-        items.forEach {
-            if (it is ContentList)
-                buildList(it, pageContext)
-            else
-                li { it.build(this, pageContext) }
-        }
-    }
-
-    override fun FlowContent.buildResource(
-        node: ContentEmbeddedResource,
-        pageContext: ContentPage
-    ) { // TODO: extension point there
-        val imageExtensions = setOf("png", "jpg", "jpeg", "gif", "bmp", "tif", "webp", "svg")
-        return if (File(node.address).extension.toLowerCase() in imageExtensions) {
-            //TODO: add imgAttrs parsing
-            val imgAttrs = node.extras.filterIsInstance<HTMLSimpleAttr>().joinAttr()
-            img(src = node.address, alt = node.altText)
-        } else {
-            println("Unrecognized resource type: $node")
-        }
-    }
-
-    override fun FlowContent.buildTable(node: ContentTable, pageContext: ContentPage) {
-        table {
-            thead {
-                node.header.forEach {
-                    tr {
-                        it.children.forEach {
-                            th {
-                                it.build(this@table, pageContext)
-                            }
-                        }
-                    }
-                }
-            }
-            tbody {
-                node.children.forEach {
-                    tr {
-                        it.children.forEach {
-                            td {
-                                it.build(this, pageContext)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    override fun FlowContent.buildHeader(level: Int, content: FlowContent.() -> Unit) {
-        when (level) {
-            1 -> h1(block = content)
-            2 -> h2(block = content)
-            3 -> h3(block = content)
-            4 -> h4(block = content)
-            else -> h5(block = content)
-        }
-    }
-
-    override fun FlowContent.buildNavigation(page: PageNode) =
-        locationProvider.ancestors(page).forEach { node ->
-            text("/")
-            buildLink(node, page)
-        }
-
-    private fun FlowContent.buildLink(to: PageNode, from: PageNode) =
-        buildLink(locationProvider.resolve(to, from)) {
-            text(to.name)
-        }
-
-    override fun buildError(node: ContentNode) {
-        context.logger.error("Unknown ContentNode type: $node")
-    }
-
-    override fun FlowContent.buildNewLine() {
-        br()
-    }
-
-    override fun FlowContent.buildLink(address: String, content: FlowContent.() -> Unit) =
-        a(href = address, block = content)
-
-    override fun FlowContent.buildCode(code: List<ContentNode>, language: String, pageContext: ContentPage) {
-        buildNewLine()
-        code.forEach {
-            +((it as? ContentText)?.text ?: run { context.logger.error("Cannot cast $it as ContentText!"); "" })
-            buildNewLine()
-        }
-    }
-
-    override fun renderPage(page: PageNode) {
-        super.renderPage(page)
-        if (page is ContentPage) {
-            pageList.add(
-                """{ "name": "${page.name}", ${if (page is ClassPageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(
-                    page
-                )}" }"""
-            )
-        }
-    }
-
-    override fun FlowContent.buildText(textNode: ContentText) {
-        text(textNode.text)
-    }
-
-    override fun render(root: RootPageNode) {
-        super.render(root)
-        outputWriter.write("scripts/pages", "var pages = [\n${pageList.joinToString(",\n")}\n]", ".js")
-    }
-
-    private fun PageNode.root(path: String) = locationProvider.resolveRoot(this) + path
-
-    override fun buildPage(page: ContentPage, content: (FlowContent, ContentPage) -> Unit): String =
-        buildHtml(page, page.embeddedResources) { content(this, page) }
-
-    open fun buildHtml(page: PageNode, resources: List<String>, content: FlowContent.() -> Unit) =
-        createHTML().html {
-            head {
-                title(page.name)
-                with(resources) {
-                    filter { it.substringBefore('?').substringAfterLast('.') == "css" }
-                        .forEach { link(rel = LinkRel.stylesheet, href = page.root(it)) }
-                    filter { it.substringBefore('?').substringAfterLast('.') == "js" }
-                        .forEach { script(type = ScriptType.textJavaScript, src = it) { async = true } }
-                }
-            }
-            body {
-                div {
-                    id = "navigation"
-                    div {
-                        id = "searchBar"
-                        form(action = page.root("-search.html"), method = FormMethod.get) {
-                            id = "searchForm"
-                            input(type = InputType.search, name = "query")
-                            input(type = InputType.submit) { value = "Search" }
-                        }
-                    }
-                    div {
-                        id = "sideMenu"
-                    }
-                }
-                div {
-                    id = "content"
-                    content()
-                }
-            }
-        }
-}
-
-fun List<HTMLMetadata>.joinAttr() = joinToString(" ") { it.key + "=" + it.value }
-
-private fun PageNode.pageKind() = when (this) {
-    is PackagePageNode -> "package"
-    is ClassPageNode -> "class"
-    is MemberPageNode -> when (this.documentable) {
-        is Function -> "function"
-        else -> "other"
-    }
-    else -> "other"
-}
diff --git a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
new file mode 100644
index 00000000..462a8acc
--- /dev/null
+++ b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -0,0 +1,218 @@
+package org.jetbrains.dokka.renderers.html
+
+import kotlinx.html.*
+import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.renderers.DefaultRenderer
+import org.jetbrains.dokka.renderers.OutputWriter
+import java.io.File
+
+open class HtmlRenderer(
+    outputWriter: OutputWriter,
+    context: DokkaContext
+) : DefaultRenderer<FlowContent>(outputWriter, context) {
+
+    private val pageList = mutableListOf<String>()
+
+    private var idCounter = 0
+        get() = ++field
+
+    private fun FlowContent.buildSideMenu(context: PageNode, node: PageNode) {
+        val children = node.children.filter { it !is MemberPageNode }
+        val submenuId = if (children.isNotEmpty()) "nav$idCounter" else null
+        div("sideMenuPart") {
+            submenuId?.also { id = it }
+            div("overview") {
+                buildLink(node, context)
+                submenuId?.also {
+                    span("navButton") {
+                        onClick = """document.getElementById("$it").classList.toggle("hidden");"""
+                        span("navButtonContent")
+                    }
+                }
+            }
+            children.forEach { buildSideMenu(context, it) }
+        }
+    }
+
+    override val preprocessors = listOf(RootCreator, SearchPageInstaller, ResourceInstaller, StyleAndScriptsAppender)
+
+    override fun FlowContent.buildList(node: ContentList, pageContext: ContentPage) =
+        if (node.ordered) ol {
+            buildListItems(node.children, pageContext)
+        }
+        else ul {
+            buildListItems(node.children, pageContext)
+        }
+
+    protected open fun OL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
+        items.forEach {
+            if (it is ContentList)
+                buildList(it, pageContext)
+            else
+                li { it.build(this, pageContext) }
+        }
+    }
+
+    protected open fun UL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
+        items.forEach {
+            if (it is ContentList)
+                buildList(it, pageContext)
+            else
+                li { it.build(this, pageContext) }
+        }
+    }
+
+    override fun FlowContent.buildResource(
+        node: ContentEmbeddedResource,
+        pageContext: ContentPage
+    ) { // TODO: extension point there
+        val imageExtensions = setOf("png", "jpg", "jpeg", "gif", "bmp", "tif", "webp", "svg")
+        return if (File(node.address).extension.toLowerCase() in imageExtensions) {
+            //TODO: add imgAttrs parsing
+            val imgAttrs = node.extras.filterIsInstance<HTMLSimpleAttr>().joinAttr()
+            img(src = node.address, alt = node.altText)
+        } else {
+            println("Unrecognized resource type: $node")
+        }
+    }
+
+    override fun FlowContent.buildTable(node: ContentTable, pageContext: ContentPage) {
+        table {
+            thead {
+                node.header.forEach {
+                    tr {
+                        it.children.forEach {
+                            th {
+                                it.build(this@table, pageContext)
+                            }
+                        }
+                    }
+                }
+            }
+            tbody {
+                node.children.forEach {
+                    tr {
+                        it.children.forEach {
+                            td {
+                                it.build(this, pageContext)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    override fun FlowContent.buildHeader(level: Int, content: FlowContent.() -> Unit) {
+        when (level) {
+            1 -> h1(block = content)
+            2 -> h2(block = content)
+            3 -> h3(block = content)
+            4 -> h4(block = content)
+            else -> h5(block = content)
+        }
+    }
+
+    override fun FlowContent.buildNavigation(page: PageNode) =
+        locationProvider.ancestors(page).forEach { node ->
+            text("/")
+            buildLink(node, page)
+        }
+
+    private fun FlowContent.buildLink(to: PageNode, from: PageNode) =
+        buildLink(locationProvider.resolve(to, from)) {
+            text(to.name)
+        }
+
+    override fun buildError(node: ContentNode) {
+        context.logger.error("Unknown ContentNode type: $node")
+    }
+
+    override fun FlowContent.buildNewLine() {
+        br()
+    }
+
+    override fun FlowContent.buildLink(address: String, content: FlowContent.() -> Unit) =
+        a(href = address, block = content)
+
+    override fun FlowContent.buildCode(code: List<ContentNode>, language: String, pageContext: ContentPage) {
+        buildNewLine()
+        code.forEach {
+            +((it as? ContentText)?.text ?: run { context.logger.error("Cannot cast $it as ContentText!"); "" })
+            buildNewLine()
+        }
+    }
+
+    override fun renderPage(page: PageNode) {
+        super.renderPage(page)
+        if (page is ContentPage) {
+            pageList.add(
+                """{ "name": "${page.name}", ${if (page is ClassPageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(
+                    page
+                )}" }"""
+            )
+        }
+    }
+
+    override fun FlowContent.buildText(textNode: ContentText) {
+        text(textNode.text)
+    }
+
+    override fun render(root: RootPageNode) {
+        super.render(root)
+        outputWriter.write("scripts/pages", "var pages = [\n${pageList.joinToString(",\n")}\n]", ".js")
+    }
+
+    private fun PageNode.root(path: String) = locationProvider.resolveRoot(this) + path
+
+    override fun buildPage(page: ContentPage, content: (FlowContent, ContentPage) -> Unit): String =
+        buildHtml(page, page.embeddedResources) { content(this, page) }
+
+    open fun buildHtml(page: PageNode, resources: List<String>, content: FlowContent.() -> Unit) =
+        createHTML().html {
+            head {
+                title(page.name)
+                with(resources) {
+                    filter { it.substringBefore('?').substringAfterLast('.') == "css" }
+                        .forEach { link(rel = LinkRel.stylesheet, href = page.root(it)) }
+                    filter { it.substringBefore('?').substringAfterLast('.') == "js" }
+                        .forEach { script(type = ScriptType.textJavaScript, src = it) { async = true } }
+                }
+            }
+            body {
+                div {
+                    id = "navigation"
+                    div {
+                        id = "searchBar"
+                        form(action = page.root("-search.html"), method = FormMethod.get) {
+                            id = "searchForm"
+                            input(type = InputType.search, name = "query")
+                            input(type = InputType.submit) { value = "Search" }
+                        }
+                    }
+                    div {
+                        id = "sideMenu"
+                    }
+                }
+                div {
+                    id = "content"
+                    content()
+                }
+            }
+        }
+}
+
+fun List<HTMLMetadata>.joinAttr() = joinToString(" ") { it.key + "=" + it.value }
+
+private fun PageNode.pageKind() = when (this) {
+    is PackagePageNode -> "package"
+    is ClassPageNode -> "class"
+    is MemberPageNode -> when (this.documentable) {
+        is Function -> "function"
+        else -> "other"
+    }
+    else -> "other"
+}
diff --git a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
new file mode 100644
index 00000000..382cb204
--- /dev/null
+++ b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -0,0 +1,57 @@
+package org.jetbrains.dokka.renderers.html
+
+import kotlinx.html.h1
+import kotlinx.html.id
+import kotlinx.html.table
+import kotlinx.html.tbody
+import org.jetbrains.dokka.pages.RendererSpecificResourcePage
+import org.jetbrains.dokka.pages.RendererSpecificRootPage
+import org.jetbrains.dokka.pages.RenderingStrategy
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
+
+object RootCreator : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) =
+        RendererSpecificRootPage("", listOf(input), RenderingStrategy.DoNothing)
+}
+
+object SearchPageInstaller : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) = input.modified(children = input.children + searchPage)
+
+    private val searchPage = RendererSpecificResourcePage(
+            name = "Search",
+            children = emptyList(),
+            strategy = RenderingStrategy<HtmlRenderer> {
+                buildHtml(it, listOf("styles/style.css", "scripts/pages.js")) {
+                    h1 {
+                        id = "searchTitle"
+                        text("Search results for ")
+                    }
+                    table {
+                        tbody {
+                            id = "searchTable"
+                        }
+                    }
+                }
+            })
+
+}
+
+object ResourceInstaller : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) = input.modified(children = input.children + resourcePages)
+
+    private val resourcePages = listOf("styles", "scripts", "images").map {
+        RendererSpecificResourcePage(it, emptyList(), RenderingStrategy.Copy("/dokka/$it"))
+    }
+}
+
+object StyleAndScriptsAppender : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
+        it.modified(
+            embeddedResources = it.embeddedResources + listOf(
+                "styles/style.css",
+                "scripts/navigationLoader.js"
+            )
+        )
+    }
+}
diff --git a/core/src/main/kotlin/renderers/htmlPreprocessors.kt b/core/src/main/kotlin/renderers/htmlPreprocessors.kt
deleted file mode 100644
index a6ad267b..00000000
--- a/core/src/main/kotlin/renderers/htmlPreprocessors.kt
+++ /dev/null
@@ -1,57 +0,0 @@
-package org.jetbrains.dokka.renderers
-
-import kotlinx.html.h1
-import kotlinx.html.id
-import kotlinx.html.table
-import kotlinx.html.tbody
-import org.jetbrains.dokka.pages.RendererSpecificResourcePage
-import org.jetbrains.dokka.pages.RendererSpecificRootPage
-import org.jetbrains.dokka.pages.RenderingStrategy
-import org.jetbrains.dokka.pages.RootPageNode
-import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
-
-object RootCreator : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) =
-        RendererSpecificRootPage("", listOf(input), RenderingStrategy.DoNothing)
-}
-
-object SearchPageInstaller : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) = input.modified(children = input.children + searchPage)
-
-    private val searchPage = RendererSpecificResourcePage(
-            name = "Search",
-            children = emptyList(),
-            strategy = RenderingStrategy<HtmlRenderer> {
-                buildHtml(it, listOf("styles/style.css", "scripts/pages.js")) {
-                    h1 {
-                        id = "searchTitle"
-                        text("Search results for ")
-                    }
-                    table {
-                        tbody {
-                            id = "searchTable"
-                        }
-                    }
-                }
-            })
-
-}
-
-object ResourceInstaller : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) = input.modified(children = input.children + resourcePages)
-
-    private val resourcePages = listOf("styles", "scripts", "images").map {
-        RendererSpecificResourcePage(it, emptyList(), RenderingStrategy.Copy("/dokka/$it"))
-    }
-}
-
-object StyleAndScriptsAppender : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
-        it.modified(
-            embeddedResources = it.embeddedResources + listOf(
-                "styles/style.css",
-                "scripts/navigationLoader.js"
-            )
-        )
-    }
-}
-- 
cgit 


From 8a354b5d9156088b35031d861fd8a7ff31c55d9b Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 3 Feb 2020 08:42:32 +0100
Subject: Implementation of transformable navigation

---
 .../main/kotlin/plugability/DefaultExtensions.kt   |  7 ++-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt | 12 +++++-
 .../main/kotlin/renderers/html/NavigationPage.kt   | 50 ++++++++++++++++++++++
 .../kotlin/renderers/html/htmlPreprocessors.kt     | 45 +++++++++++--------
 .../resources/dokka/scripts/navigationLoader.js    | 12 ++++++
 5 files changed, 107 insertions(+), 19 deletions(-)
 create mode 100644 core/src/main/kotlin/renderers/html/NavigationPage.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 9f36b2a4..c62bdd41 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -12,7 +12,12 @@ import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
 
 internal object DefaultExtensions {
 
-    private val renderer: LazyEvaluated<HtmlRenderer> = LazyEvaluated.fromRecipe { HtmlRenderer(it.single(CoreExtensions.outputWriter), it) }
+    private val renderer: LazyEvaluated<HtmlRenderer> = LazyEvaluated.fromRecipe {
+        HtmlRenderer(
+            it.single(CoreExtensions.outputWriter),
+            it
+        )
+    }
     private val converter: LazyEvaluated<DocTagToContentConverter> = LazyEvaluated.fromRecipe { DocTagToContentConverter(it) }
     private val providerFactory: LazyEvaluated<DefaultLocationProviderFactory> = LazyEvaluated.fromRecipe { DefaultLocationProviderFactory(it) }
 
diff --git a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
index d0738289..d5dfb827 100644
--- a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -2,11 +2,13 @@ package org.jetbrains.dokka.renderers.html
 
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.renderers.DefaultRenderer
 import org.jetbrains.dokka.renderers.OutputWriter
+import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 import java.io.File
 
 open class HtmlRenderer(
@@ -20,7 +22,7 @@ open class HtmlRenderer(
         RootCreator,
         SearchPageInstaller,
         ResourceInstaller,
-        NavigationInstaller,
+        NavigationPageInstaller,
         StyleAndScriptsAppender
     )
 
@@ -112,6 +114,13 @@ open class HtmlRenderer(
             text(to.name)
         }
 
+    fun FlowContent.buildLink(
+        to: DRI,
+        platforms: List<PlatformData>,
+        from: PageNode? = null,
+        block: FlowContent.() -> Unit
+    ) = buildLink(locationProvider.resolve(to, platforms, from), block)
+
     override fun buildError(node: ContentNode) {
         context.logger.error("Unknown ContentNode type: $node")
     }
@@ -166,6 +175,7 @@ open class HtmlRenderer(
                     filter { it.substringBefore('?').substringAfterLast('.') == "js" }
                         .forEach { script(type = ScriptType.textJavaScript, src = it) { async = true } }
                 }
+                script { unsafe { +"""var pathToRoot = "${locationProvider.resolveRoot(page)}";""" } }
             }
             body {
                 div {
diff --git a/core/src/main/kotlin/renderers/html/NavigationPage.kt b/core/src/main/kotlin/renderers/html/NavigationPage.kt
new file mode 100644
index 00000000..4a2fb40d
--- /dev/null
+++ b/core/src/main/kotlin/renderers/html/NavigationPage.kt
@@ -0,0 +1,50 @@
+package org.jetbrains.dokka.renderers.html
+
+import kotlinx.html.*
+import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.pages.RendererSpecificPage
+import org.jetbrains.dokka.pages.RenderingStrategy
+
+class NavigationPage(val root: NavigationNode) : RendererSpecificPage {
+    override val name = "navigation"
+
+    override val children = emptyList<PageNode>()
+
+    override fun modified(name: String, children: List<PageNode>) = this
+
+    override val strategy = RenderingStrategy<HtmlRenderer> {
+        createHTML().visit(root, "nav-submenu", this)
+    }
+
+    private fun <R> TagConsumer<R>.visit(node: NavigationNode, navId: String, renderer: HtmlRenderer): R =
+        with(renderer) {
+            div("sideMenuPart") {
+                id = navId
+                div("overview") {
+                    buildLink(node.dri, node.platforms) { +node.name }
+                    if (node.children.isNotEmpty()) {
+                        span("navButton") {
+                            onClick = """document.getElementById("$navId").classList.toggle("hidden");"""
+                            span("navButtonContent")
+                        }
+                    }
+                }
+                node.children.withIndex().forEach { (n, p) -> visit(p, "$navId-$n", renderer) }
+            }
+        }
+}
+
+class NavigationNode(
+    val name: String,
+    val dri: DRI,
+    val platforms: List<PlatformData>,
+    val children: List<NavigationNode>
+)
+
+fun NavigationPage.transform(block: (NavigationNode) -> NavigationNode) = NavigationPage(root.transform(block))
+
+fun NavigationNode.transform(block: (NavigationNode) -> NavigationNode) =
+    run(block).let { NavigationNode(it.name, it.dri, it.platforms, it.children.map(block)) }
diff --git a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
index 382cb204..22856368 100644
--- a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
+++ b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -4,10 +4,8 @@ import kotlinx.html.h1
 import kotlinx.html.id
 import kotlinx.html.table
 import kotlinx.html.tbody
-import org.jetbrains.dokka.pages.RendererSpecificResourcePage
-import org.jetbrains.dokka.pages.RendererSpecificRootPage
-import org.jetbrains.dokka.pages.RenderingStrategy
-import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.renderers.platforms
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
 object RootCreator : PageNodeTransformer {
@@ -19,22 +17,35 @@ object SearchPageInstaller : PageNodeTransformer {
     override fun invoke(input: RootPageNode) = input.modified(children = input.children + searchPage)
 
     private val searchPage = RendererSpecificResourcePage(
-            name = "Search",
-            children = emptyList(),
-            strategy = RenderingStrategy<HtmlRenderer> {
-                buildHtml(it, listOf("styles/style.css", "scripts/pages.js")) {
-                    h1 {
-                        id = "searchTitle"
-                        text("Search results for ")
-                    }
-                    table {
-                        tbody {
-                            id = "searchTable"
-                        }
+        name = "Search",
+        children = emptyList(),
+        strategy = RenderingStrategy<HtmlRenderer> {
+            buildHtml(it, listOf("styles/style.css", "scripts/pages.js")) {
+                h1 {
+                    id = "searchTitle"
+                    text("Search results for ")
+                }
+                table {
+                    tbody {
+                        id = "searchTable"
                     }
                 }
-            })
+            }
+        })
+}
+
+object NavigationPageInstaller : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) = input.modified(
+        children = input.children + NavigationPage(
+            input.children.filterIsInstance<ContentPage>().single().let(::visit)
+        )
+    )
 
+    private fun visit(page: ContentPage): NavigationNode = NavigationNode(
+        page.name,
+        page.dri,
+        page.platforms(),
+        page.children.filterIsInstance<ContentPage>().map { visit(it) })
 }
 
 object ResourceInstaller : PageNodeTransformer {
diff --git a/core/src/main/resources/dokka/scripts/navigationLoader.js b/core/src/main/resources/dokka/scripts/navigationLoader.js
index e69de29b..d79203f2 100644
--- a/core/src/main/resources/dokka/scripts/navigationLoader.js
+++ b/core/src/main/resources/dokka/scripts/navigationLoader.js
@@ -0,0 +1,12 @@
+onload = () => {
+    fetch(pathToRoot + "navigation")
+    .then(response => response.text())
+    .then(data => {
+        document.getElementById("sideMenu").innerHTML = data;
+    }).then(() => {
+        document.querySelectorAll(".overview > a").forEach(link => {
+            link.setAttribute("href", pathToRoot + link.getAttribute("href"))
+            console.log(link.attributes["href"])
+        })
+    })
+}
\ No newline at end of file
-- 
cgit 


From 1882138d0558d0465c97f34ac86a7b5102de0191 Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Tue, 4 Feb 2020 11:53:31 +0100
Subject: Adds conditional plugin linking

---
 core/src/main/kotlin/plugability/DokkaContext.kt |  4 +--
 core/src/main/kotlin/plugability/DokkaPlugin.kt  |  5 ++--
 core/src/main/kotlin/plugability/extensions.kt   | 31 ++++++++++++++++++------
 3 files changed, 29 insertions(+), 11 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 0d110f85..e6286f0b 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -105,7 +105,7 @@ private class DokkaContextConfigurationImpl(
             AskDefault.Never -> actions(point).orEmpty()
             AskDefault.Always -> actions(point).orEmpty() + DefaultExtensions.get(point, this)
             AskDefault.WhenEmpty ->
-                actions(point)?.takeIf { it.isNotEmpty() } ?: DefaultExtensions?.get(point, this)
+                actions(point)?.takeIf { it.isNotEmpty() } ?: DefaultExtensions.get(point, this)
         } as List<T>
 
     private fun <E : ExtensionPoint<*>> actions(point: E) = extensions[point]?.map { it.action.get(this) }
@@ -119,7 +119,7 @@ private class DokkaContextConfigurationImpl(
     fun install(plugin: DokkaPlugin) {
         plugins[plugin::class] = plugin
         plugin.context = this
-        plugin.internalInstall(this)
+        plugin.internalInstall(this, this.configuration)
     }
 
     override fun addExtensionDependencies(extension: Extension<*>) {
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 3f82000d..1fcbd934 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.plugability
 
+import org.jetbrains.dokka.DokkaConfiguration
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
@@ -36,10 +37,10 @@ abstract class DokkaPlugin {
         }.also { thisRef.extensionDelegates += property }
     }
 
-    internal fun internalInstall(ctx: DokkaContextConfiguration) {
+    internal fun internalInstall(ctx: DokkaContextConfiguration, configuration: DokkaConfiguration) {
         extensionDelegates.asSequence()
             .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // should be always true
             .map { it.get(this) }
-            .forEach { ctx.addExtensionDependencies(it) }
+            .forEach { if(it.condition.invoke(configuration)) ctx.addExtensionDependencies(it) }
     }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index 42bf3900..4cbb61eb 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -1,5 +1,7 @@
 package org.jetbrains.dokka.plugability
 
+import org.jetbrains.dokka.DokkaConfiguration
+
 data class ExtensionPoint<T : Any> internal constructor(
     internal val pluginClass: String,
     internal val pointName: String
@@ -12,7 +14,8 @@ abstract class Extension<T : Any> internal constructor(
     internal val pluginClass: String,
     internal val extensionName: String,
     internal val action: LazyEvaluated<T>,
-    internal val ordering: (OrderDsl.() -> Unit)? = null
+    internal val ordering: (OrderDsl.() -> Unit)? = null,
+    internal val condition: DokkaConfiguration.() -> Boolean = { true }
 ) {
     override fun toString() = "Extension: $pluginClass/$extensionName"
 
@@ -21,6 +24,8 @@ abstract class Extension<T : Any> internal constructor(
         else false
 
     override fun hashCode() = listOf(pluginClass, extensionName).hashCode()
+
+    abstract fun setCondition(condition: (DokkaConfiguration.() -> Boolean)): Extension<T>
 }
 
 class ExtensionOrdered<T : Any> internal constructor(
@@ -28,27 +33,37 @@ class ExtensionOrdered<T : Any> internal constructor(
     pluginClass: String,
     extensionName: String,
     action: LazyEvaluated<T>,
-    ordering: (OrderDsl.() -> Unit)
+    ordering: (OrderDsl.() -> Unit),
+    condition: DokkaConfiguration.() -> Boolean = { true }
 ) : Extension<T>(
     extensionPoint,
     pluginClass,
     extensionName,
     action,
-    ordering
-)
+    ordering,
+    condition
+) {
+    override fun setCondition(condition: DokkaConfiguration.() -> Boolean) =
+        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, condition)
+}
 
 class ExtensionUnordered<T : Any> internal constructor(
     extensionPoint: ExtensionPoint<T>,
     pluginClass: String,
     extensionName: String,
-    action: LazyEvaluated<T>
+    action: LazyEvaluated<T>,
+    condition: DokkaConfiguration.() -> Boolean = { true }
 ) : Extension<T>(
     extensionPoint,
     pluginClass,
     extensionName,
     action,
-    null
-)
+    null,
+    condition
+) {
+    override fun setCondition(condition: DokkaConfiguration.() -> Boolean) =
+        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, condition)
+}
 
 internal data class Ordering(val previous: Set<Extension<*>>, val following: Set<Extension<*>>)
 
@@ -66,6 +81,8 @@ class ExtendingDSL(private val pluginClass: String, private val extensionName: S
 
     infix fun <T: Any> ExtensionUnordered<T>.order(block: OrderDsl.() -> Unit) =
         ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, block)
+
+    infix fun <T : Any> Extension<T>.applyIf(condition: DokkaConfiguration.() -> Boolean): Extension<T> = this.setCondition(condition)
 }
 
 @ExtensionsDsl
-- 
cgit 


From 0d430649e966454e808874d7555340be5496ca9d Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Wed, 5 Feb 2020 10:21:49 +0100
Subject: Cleans up file extension redundancy

---
 core/src/main/kotlin/plugability/DefaultExtensions.kt |  5 +++--
 core/src/main/kotlin/renderers/DefaultRenderer.kt     |  4 +---
 core/src/main/kotlin/renderers/FileWriter.kt          |  3 ++-
 core/src/main/kotlin/renderers/OutputWriter.kt        | 10 +++++++++-
 4 files changed, 15 insertions(+), 7 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index c62bdd41..029d21de 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -3,6 +3,7 @@ package org.jetbrains.dokka.plugability
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.DocTagToContentConverter
 import org.jetbrains.dokka.renderers.FileWriter
+import org.jetbrains.dokka.renderers.OutputWriter
 import org.jetbrains.dokka.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
@@ -20,7 +21,7 @@ internal object DefaultExtensions {
     }
     private val converter: LazyEvaluated<DocTagToContentConverter> = LazyEvaluated.fromRecipe { DocTagToContentConverter(it) }
     private val providerFactory: LazyEvaluated<DefaultLocationProviderFactory> = LazyEvaluated.fromRecipe { DefaultLocationProviderFactory(it) }
-
+    private val outputWriter: LazyEvaluated<OutputWriter> = LazyEvaluated.fromRecipe { FileWriter(it) }
 
     @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
@@ -32,7 +33,7 @@ internal object DefaultExtensions {
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
             CoreExtensions.renderer -> renderer.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
-            CoreExtensions.outputWriter ->  FileWriter(fullContext, "")
+            CoreExtensions.outputWriter ->  outputWriter.get(fullContext)
             CoreExtensions.fileExtension -> ".html"
             else -> null
         }.let { listOfNotNull( it ) as List<T> }
diff --git a/core/src/main/kotlin/renderers/DefaultRenderer.kt b/core/src/main/kotlin/renderers/DefaultRenderer.kt
index cdd28737..4b4d6fd3 100644
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/core/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -12,8 +12,6 @@ abstract class DefaultRenderer<T>(
     protected val context: DokkaContext
 ) : Renderer {
 
-    private val extension = context.single(CoreExtensions.fileExtension)
-
     protected lateinit var locationProvider: LocationProvider
         private set
 
@@ -77,7 +75,7 @@ abstract class DefaultRenderer<T>(
     open fun renderPage(page: PageNode) {
         val path by lazy { locationProvider.resolve(page, skipExtension = true) }
         when (page) {
-            is ContentPage -> outputWriter.write(path, buildPage(page) { c, p -> buildPageContent(c, p) }, extension)
+            is ContentPage -> outputWriter.write(path, buildPage(page) { c, p -> buildPageContent(c, p) })
             is RendererSpecificPage -> when (val strategy = page.strategy) {
                 is RenderingStrategy.Copy -> outputWriter.writeResources(strategy.from, path)
                 is RenderingStrategy.Write -> outputWriter.write(path, strategy.text, "")
diff --git a/core/src/main/kotlin/renderers/FileWriter.kt b/core/src/main/kotlin/renderers/FileWriter.kt
index 78cfdde7..83bb9ce3 100644
--- a/core/src/main/kotlin/renderers/FileWriter.kt
+++ b/core/src/main/kotlin/renderers/FileWriter.kt
@@ -6,10 +6,11 @@ import java.io.IOException
 import java.net.URI
 import java.nio.file.*
 
-class FileWriter(val context: DokkaContext, override val extension: String): OutputWriter {
+class FileWriter(override val context: DokkaContext): OutputWriter {
     private val createdFiles: MutableSet<String> = mutableSetOf()
     private val jarUriPrefix = "jar:file:"
     private val root = context.configuration.outputDir
+
     override fun write(path: String, text: String, ext: String) {
         if (createdFiles.contains(path)) {
             context.logger.error("An attempt to write ${root}/$path several times!")
diff --git a/core/src/main/kotlin/renderers/OutputWriter.kt b/core/src/main/kotlin/renderers/OutputWriter.kt
index 8ef7e8b2..b2059aa3 100644
--- a/core/src/main/kotlin/renderers/OutputWriter.kt
+++ b/core/src/main/kotlin/renderers/OutputWriter.kt
@@ -1,7 +1,15 @@
 package org.jetbrains.dokka.renderers
 
-interface OutputWriter{
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.single
+
+interface OutputWriter {
+
+    val context: DokkaContext
     val extension: String
+        get() = context.single(CoreExtensions.fileExtension)
+    
     fun write(path: String, text: String, ext: String = extension)
     fun writeResources(pathFrom: String, pathTo: String)
 }
\ No newline at end of file
-- 
cgit 


From 5a432c9c62ff95779a495fb354c83f5f7c481a1d Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Tue, 11 Feb 2020 15:33:37 +0100
Subject: Removed default file extension extension point

---
 core/src/main/kotlin/CoreExtensions.kt                    | 1 -
 core/src/main/kotlin/plugability/DefaultExtensions.kt     | 1 -
 core/src/main/kotlin/renderers/DefaultRenderer.kt         | 4 ++--
 core/src/main/kotlin/renderers/FileWriter.kt              | 2 +-
 core/src/main/kotlin/renderers/OutputWriter.kt            | 6 +-----
 core/src/main/kotlin/resolvers/DefaultLocationProvider.kt | 2 +-
 6 files changed, 5 insertions(+), 11 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 46b241a7..8c66b41e 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -29,7 +29,6 @@ object CoreExtensions {
     val locationProviderFactory by coreExtension<LocationProviderFactory>()
     val outputWriter by coreExtension<OutputWriter>()
     val renderer by coreExtension<Renderer>()
-    val fileExtension by coreExtension<String>()
 
     private fun <T: Any> coreExtension() = object {
         operator fun provideDelegate(thisRef: CoreExtensions, property: KProperty<*>): Lazy<ExtensionPoint<T>> =
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 029d21de..d6331b86 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -34,7 +34,6 @@ internal object DefaultExtensions {
             CoreExtensions.renderer -> renderer.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
             CoreExtensions.outputWriter ->  outputWriter.get(fullContext)
-            CoreExtensions.fileExtension -> ".html"
             else -> null
         }.let { listOfNotNull( it ) as List<T> }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/DefaultRenderer.kt b/core/src/main/kotlin/renderers/DefaultRenderer.kt
index 4b4d6fd3..16cdb4c1 100644
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/core/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -75,11 +75,11 @@ abstract class DefaultRenderer<T>(
     open fun renderPage(page: PageNode) {
         val path by lazy { locationProvider.resolve(page, skipExtension = true) }
         when (page) {
-            is ContentPage -> outputWriter.write(path, buildPage(page) { c, p -> buildPageContent(c, p) })
+            is ContentPage -> outputWriter.write(path, buildPage(page) { c, p -> buildPageContent(c, p) }, ".html")
             is RendererSpecificPage -> when (val strategy = page.strategy) {
                 is RenderingStrategy.Copy -> outputWriter.writeResources(strategy.from, path)
                 is RenderingStrategy.Write -> outputWriter.write(path, strategy.text, "")
-                is RenderingStrategy.Callback -> outputWriter.write(path, strategy.instructions(this, page))
+                is RenderingStrategy.Callback -> outputWriter.write(path, strategy.instructions(this, page), ".html")
                 RenderingStrategy.DoNothing -> Unit
             }
             else -> throw AssertionError(
diff --git a/core/src/main/kotlin/renderers/FileWriter.kt b/core/src/main/kotlin/renderers/FileWriter.kt
index 83bb9ce3..727a8d21 100644
--- a/core/src/main/kotlin/renderers/FileWriter.kt
+++ b/core/src/main/kotlin/renderers/FileWriter.kt
@@ -6,7 +6,7 @@ import java.io.IOException
 import java.net.URI
 import java.nio.file.*
 
-class FileWriter(override val context: DokkaContext): OutputWriter {
+class FileWriter(val context: DokkaContext): OutputWriter {
     private val createdFiles: MutableSet<String> = mutableSetOf()
     private val jarUriPrefix = "jar:file:"
     private val root = context.configuration.outputDir
diff --git a/core/src/main/kotlin/renderers/OutputWriter.kt b/core/src/main/kotlin/renderers/OutputWriter.kt
index b2059aa3..30b2b0b6 100644
--- a/core/src/main/kotlin/renderers/OutputWriter.kt
+++ b/core/src/main/kotlin/renderers/OutputWriter.kt
@@ -6,10 +6,6 @@ import org.jetbrains.dokka.plugability.single
 
 interface OutputWriter {
 
-    val context: DokkaContext
-    val extension: String
-        get() = context.single(CoreExtensions.fileExtension)
-    
-    fun write(path: String, text: String, ext: String = extension)
+    fun write(path: String, text: String, ext: String)
     fun writeResources(pathFrom: String, pathTo: String)
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
index cac7b740..d30264bb 100644
--- a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
+++ b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
@@ -14,7 +14,7 @@ open class DefaultLocationProvider(
     protected val pageGraphRoot: RootPageNode,
     protected val dokkaContext: DokkaContext
 ) : LocationProvider {
-    protected val extension = dokkaContext.single(CoreExtensions.fileExtension)
+    protected val extension = ".html"
 
     protected val pagesIndex: Map<DRI, ContentPage> = pageGraphRoot.asSequence().filterIsInstance<ContentPage>()
         .map { it.dri.map { dri -> dri to it } }.flatten()
-- 
cgit 


From 8c534f14296a92fedc3410fb48de51836cb92859 Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Wed, 5 Feb 2020 12:07:21 +0100
Subject: merger for functions

---
 core/src/main/kotlin/pages/PageNodes.kt            | 10 +++--
 .../main/kotlin/plugability/DefaultExtensions.kt   |  2 +
 .../transformers/pages/DefaultPageNodeMerger.kt    | 45 ++++++++++++++++++++++
 3 files changed, 54 insertions(+), 3 deletions(-)
 create mode 100644 core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index 6b67a734..244d951e 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -24,6 +24,7 @@ interface ContentPage: PageNode {
     fun modified(
         name: String = this.name,
         content: ContentNode = this.content,
+        dri: Set<DRI> = this.dri,
         embeddedResources: List<String> = this.embeddedResources,
         children: List<PageNode> = this.children
     ): ContentPage
@@ -63,7 +64,6 @@ abstract class RootPageNode: PageNode {
 class ModulePageNode(
     override val name: String,
     override val content: ContentNode,
-
     override val documentable: Documentable?,
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
@@ -71,11 +71,12 @@ class ModulePageNode(
     override val dri: Set<DRI> = setOf(DRI.topLevel)
 
     override fun modified(name: String, children: List<PageNode>): ModulePageNode =
-        modified(name = name, content = this.content, children = children)
+        modified(name = name, content = this.content, dri = dri, children = children)
 
     override fun modified(
         name: String,
         content: ContentNode,
+        dri: Set<DRI>,
         embeddedResources: List<String>,
         children: List<PageNode>
     ): ModulePageNode =
@@ -98,6 +99,7 @@ class PackagePageNode(
     override fun modified(
         name: String,
         content: ContentNode,
+        dri: Set<DRI>,
         embeddedResources: List<String>,
         children: List<PageNode>
     ): PackagePageNode =
@@ -119,6 +121,7 @@ class ClasslikePageNode(
     override fun modified(
         name: String,
         content: ContentNode,
+        dri: Set<DRI>,
         embeddedResources: List<String>,
         children: List<PageNode>
     ): ClasslikePageNode =
@@ -135,11 +138,12 @@ class MemberPageNode(
     override val embeddedResources: List<String> = listOf()
 ) : ContentPage {
     override fun modified(name: String, children: List<PageNode>): MemberPageNode =
-        modified(name = name, content = this.content, children = children)
+        modified(name = name, content = this.content, children = children) as MemberPageNode
 
     override fun modified(
         name: String,
         content: ContentNode,
+        dri: Set<DRI>,
         embeddedResources: List<String>,
         children: List<PageNode>
     ): MemberPageNode =
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index d6331b86..b7ab1af1 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -10,6 +10,7 @@ import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumenta
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
 import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
+import org.jetbrains.dokka.transformers.pages.DefaultPageNodeMerger
 
 internal object DefaultExtensions {
 
@@ -31,6 +32,7 @@ internal object DefaultExtensions {
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
             CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
+            CoreExtensions.pageTransformer -> DefaultPageNodeMerger
             CoreExtensions.renderer -> renderer.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
             CoreExtensions.outputWriter ->  outputWriter.get(fullContext)
diff --git a/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt b/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
new file mode 100644
index 00000000..7cd4aba8
--- /dev/null
+++ b/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
@@ -0,0 +1,45 @@
+package org.jetbrains.dokka.transformers.pages
+
+import org.jetbrains.dokka.pages.*
+
+object DefaultPageNodeMerger : PageNodeTransformer {
+    override fun invoke(input: RootPageNode): RootPageNode =
+        input.modified(children = input.children.map { it.mergeChildren() })
+
+    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
+        val n = nodes.first()
+        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
+    }
+
+    fun PageNode.mergeChildren(): PageNode = if (children.isNotEmpty()) {
+        children.groupBy { it.name }
+            .map { (k, v) ->
+                if (v.size > 1) {
+                    v.mergePageNodes(k)
+                } else v.first()
+            }
+            .map { it.mergeChildren() }
+            .let {
+                modified(children = it)
+            }
+    } else this
+
+    private fun List<PageNode>.mergePageNodes(
+        k: String
+    ): ContentPage {
+        val resChildren = this.flatMap { it.children }.distinct()
+        val contentChildren = this.filterIsInstance<ContentPage>()
+        val dri = contentChildren.flatMap { it.dri }.toSet()
+        val dci = DCI(
+            dri = dri,
+            kind = contentChildren.first().content.dci.kind
+        )
+        return contentChildren.first()
+            .modified(
+                dri = dri,
+                name = k,
+                children = resChildren,
+                content = asGroup(dci, contentChildren.map { it.content })
+            )
+    }
+}
\ No newline at end of file
-- 
cgit 


From 2a60f8adbab66e7b671949960c7cd90ea86992d7 Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Tue, 11 Feb 2020 17:01:06 +0100
Subject: plugin overrides

---
 core/src/main/kotlin/DokkaGenerator.kt                           | 7 ++++---
 core/src/main/kotlin/plugability/DokkaContext.kt                 | 4 +++-
 testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt | 6 ++++--
 testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt         | 7 +++++--
 4 files changed, 16 insertions(+), 8 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index fef71aab..a31c04a6 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -6,10 +6,10 @@ import com.intellij.psi.PsiManager
 import org.jetbrains.dokka.analysis.AnalysisEnvironment
 import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.model.Module
-import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
@@ -66,8 +66,9 @@ class DokkaGenerator(
     fun initializePlugins(
         configuration: DokkaConfiguration,
         logger: DokkaLogger,
-        platforms: Map<PlatformData, EnvironmentAndFacade>
-    ) = DokkaContext.create(configuration, logger, platforms)
+        platforms: Map<PlatformData, EnvironmentAndFacade>,
+        pluginOverrides: List<DokkaPlugin> = emptyList()
+    ) = DokkaContext.create(configuration, logger, platforms, pluginOverrides)
 
     fun createDocumentationModels(
         platforms: Map<PlatformData, EnvironmentAndFacade>,
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index e6286f0b..6a8ac4a3 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -25,7 +25,8 @@ interface DokkaContext {
         fun create(
             configuration: DokkaConfiguration,
             logger: DokkaLogger,
-            platforms: Map<PlatformData, EnvironmentAndFacade>
+            platforms: Map<PlatformData, EnvironmentAndFacade>,
+            pluginOverrides: List<DokkaPlugin>
         ): DokkaContext =
             DokkaContextConfigurationImpl(logger, configuration, platforms).apply {
                 configuration.pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
@@ -33,6 +34,7 @@ interface DokkaContext {
                     .let { URLClassLoader(it, this.javaClass.classLoader) }
                     .also { checkClasspath(it) }
                     .let { ServiceLoader.load(DokkaPlugin::class.java, it) }
+                    .let { it + pluginOverrides }
                     .forEach { install(it) }
                 applyExtensions()
             }.also { it.logInitialisationInfo() }
diff --git a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
index 50e88f2b..21bbe72d 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
@@ -4,12 +4,14 @@ import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.DokkaGenerator
 import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
 
 internal class DokkaTestGenerator(
     private val configuration: DokkaConfiguration,
     private val logger: DokkaLogger,
-    private val testMethods: TestMethods
+    private val testMethods: TestMethods,
+    private val pluginOverrides: List<DokkaPlugin> = emptyList()
 ) {
 
     fun generate() = with(testMethods) {
@@ -18,7 +20,7 @@ internal class DokkaTestGenerator(
         val platforms: Map<PlatformData, EnvironmentAndFacade> = dokkaGenerator.setUpAnalysis(configuration)
         analysisSetupStage(platforms)
 
-        val context = dokkaGenerator.initializePlugins(configuration, logger, platforms)
+        val context = dokkaGenerator.initializePlugins(configuration, logger, platforms, pluginOverrides)
         pluginsSetupStage(context)
 
         val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(platforms, context)
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index fa61bf59..b8817918 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -6,6 +6,7 @@ import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import org.junit.rules.TemporaryFolder
 import java.io.File
@@ -26,6 +27,7 @@ abstract class AbstractCoreTest {
     protected fun testFromData(
         configuration: DokkaConfigurationImpl,
         cleanupOutput: Boolean = true,
+        pluginOverrides: List<DokkaPlugin> = emptyList(),
         block: TestBuilder.() -> Unit
     ) {
         val testMethods = TestBuilder().apply(block).build()
@@ -36,13 +38,14 @@ abstract class AbstractCoreTest {
             configuration.copy(
                 outputDir = tempDir.root.toPath().toAbsolutePath().toString()
             )
-        DokkaTestGenerator(newConfiguration, logger, testMethods).generate()
+        DokkaTestGenerator(newConfiguration, logger, testMethods, pluginOverrides).generate()
     }
 
     protected fun testInline(
         query: String,
         configuration: DokkaConfigurationImpl,
         cleanupOutput: Boolean = true,
+        pluginOverrides: List<DokkaPlugin> = emptyList(),
         block: TestBuilder.() -> Unit
     ) {
         val testMethods = TestBuilder().apply(block).build()
@@ -57,7 +60,7 @@ abstract class AbstractCoreTest {
                 passesConfigurations = configuration.passesConfigurations
                     .map { it.copy(sourceRoots = it.sourceRoots.map { it.copy(path = "${testDirPath.toAbsolutePath()}/${it.path}") }) }
             )
-        DokkaTestGenerator(newConfiguration, logger, testMethods).generate()
+        DokkaTestGenerator(newConfiguration, logger, testMethods, pluginOverrides).generate()
     }
 
     private fun String.toFileMap(): Map<String, String> = this.trimMargin().removePrefix("|")
-- 
cgit 


From 1e0271e4e2888022f2ac93366c397d7315008c45 Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Thu, 6 Feb 2020 15:51:07 +0100
Subject: page merger strategy

---
 core/src/main/kotlin/CoreExtensions.kt             |  3 ++
 .../main/kotlin/plugability/DefaultExtensions.kt   |  4 +-
 .../kotlin/renderers/html/htmlPreprocessors.kt     | 10 ++---
 .../pages/DefaultPageMergerStrategy.kt             | 30 +++++++++++++
 .../transformers/pages/DefaultPageNodeMerger.kt    | 50 ++++++----------------
 .../transformers/pages/PageMergerStrategy.kt       |  9 ++++
 .../transformers/pages/PageNodeTransformer.kt      |  4 +-
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt   |  2 +-
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |  2 +-
 9 files changed, 68 insertions(+), 46 deletions(-)
 create mode 100644 core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
 create mode 100644 core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 8c66b41e..18cde210 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -9,6 +9,7 @@ import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTra
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeTransformer
 import org.jetbrains.dokka.transformers.documentation.DocumentationToPageTranslator
+import org.jetbrains.dokka.transformers.pages.PageMergerStrategy
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 import org.jetbrains.dokka.transformers.psi.PsiToDocumentationTranslator
 import kotlin.reflect.KProperty
@@ -29,6 +30,8 @@ object CoreExtensions {
     val locationProviderFactory by coreExtension<LocationProviderFactory>()
     val outputWriter by coreExtension<OutputWriter>()
     val renderer by coreExtension<Renderer>()
+    val fileExtension by coreExtension<String>()
+    val pageMergerStrategy by coreExtension<PageMergerStrategy>()
 
     private fun <T: Any> coreExtension() = object {
         operator fun provideDelegate(thisRef: CoreExtensions, property: KProperty<*>): Lazy<ExtensionPoint<T>> =
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index b7ab1af1..3f630ee3 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -9,6 +9,7 @@ import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
+import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
 import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageNodeMerger
 
@@ -32,10 +33,11 @@ internal object DefaultExtensions {
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
             CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
-            CoreExtensions.pageTransformer -> DefaultPageNodeMerger
+            CoreExtensions.pageTransformer -> DefaultPageNodeMerger(fullContext)
             CoreExtensions.renderer -> renderer.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
             CoreExtensions.outputWriter ->  outputWriter.get(fullContext)
+            CoreExtensions.pageMergerStrategy -> DefaultPageMergerStrategy
             else -> null
         }.let { listOfNotNull( it ) as List<T> }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
index 4ee67448..7ce6d298 100644
--- a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
+++ b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -8,12 +8,12 @@ import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.renderers.platforms
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
-object RootCreator : PageNodeTransformer {
+object RootCreator : PageNodeTransformer() {
     override fun invoke(input: RootPageNode) =
         RendererSpecificRootPage("", listOf(input), RenderingStrategy.DoNothing)
 }
 
-object SearchPageInstaller : PageNodeTransformer {
+object SearchPageInstaller : PageNodeTransformer() {
     override fun invoke(input: RootPageNode) = input.modified(children = input.children + searchPage)
 
     private val searchPage = RendererSpecificResourcePage(
@@ -34,7 +34,7 @@ object SearchPageInstaller : PageNodeTransformer {
         })
 }
 
-object NavigationPageInstaller : PageNodeTransformer {
+object NavigationPageInstaller : PageNodeTransformer() {
     override fun invoke(input: RootPageNode) = input.modified(
         children = input.children + NavigationPage(
             input.children.filterIsInstance<ContentPage>().single().let(::visit)
@@ -48,7 +48,7 @@ object NavigationPageInstaller : PageNodeTransformer {
         page.children.filterIsInstance<ContentPage>().map { visit(it) })
 }
 
-object ResourceInstaller : PageNodeTransformer {
+object ResourceInstaller : PageNodeTransformer() {
     override fun invoke(input: RootPageNode) = input.modified(children = input.children + resourcePages)
 
     private val resourcePages = listOf("styles", "scripts", "images").map {
@@ -56,7 +56,7 @@ object ResourceInstaller : PageNodeTransformer {
     }
 }
 
-object StyleAndScriptsAppender : PageNodeTransformer {
+object StyleAndScriptsAppender : PageNodeTransformer() {
     override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
         it.modified(
             embeddedResources = it.embeddedResources + listOf(
diff --git a/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
new file mode 100644
index 00000000..81da71ce
--- /dev/null
+++ b/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.dokka.transformers.pages
+
+import org.jetbrains.dokka.pages.*
+
+object DefaultPageMergerStrategy : PageMergerStrategy() {
+    override fun tryMerge(pages: List<PageNode>): List<PageNode> = listOf(pages.mergePageNodes())
+
+    private fun List<PageNode>.mergePageNodes(): ContentPage {
+        val name = first().name
+        val resChildren = this.flatMap { it.children }.distinct()
+        val contentChildren = this.filterIsInstance<ContentPage>()
+        val dri = contentChildren.flatMap { it.dri }.toSet()
+        val dci = DCI(
+            dri = dri,
+            kind = contentChildren.first().content.dci.kind
+        )
+        return contentChildren.first()
+            .modified(
+                dri = dri,
+                name = name,
+                children = resChildren,
+                content = asGroup(dci, contentChildren.map { it.content })
+            )
+    }
+
+    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
+        val n = nodes.first()
+        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt b/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
index 7cd4aba8..72e491cf 100644
--- a/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
@@ -1,45 +1,23 @@
 package org.jetbrains.dokka.transformers.pages
 
-import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.plugability.DokkaContext
 
-object DefaultPageNodeMerger : PageNodeTransformer {
+class DefaultPageNodeMerger(val context: DokkaContext) : PageNodeTransformer(context) {
     override fun invoke(input: RootPageNode): RootPageNode =
         input.modified(children = input.children.map { it.mergeChildren() })
 
-    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
-        val n = nodes.first()
-        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
-    }
+    fun PageNode.mergeChildren(): PageNode = children.groupBy { it.name }
+        .map { (_, v) -> v.mergePageNodes() }
+        .let { pages -> modified(children = pages.map { it.first().mergeChildren() }) }
 
-    fun PageNode.mergeChildren(): PageNode = if (children.isNotEmpty()) {
-        children.groupBy { it.name }
-            .map { (k, v) ->
-                if (v.size > 1) {
-                    v.mergePageNodes(k)
-                } else v.first()
-            }
-            .map { it.mergeChildren() }
-            .let {
-                modified(children = it)
-            }
-    } else this
+    private fun List<PageNode>.mergePageNodes(): List<PageNode> =
+        context[CoreExtensions.pageMergerStrategy].fold(this) { pages, strategy -> tryMerge(strategy, pages) }
 
-    private fun List<PageNode>.mergePageNodes(
-        k: String
-    ): ContentPage {
-        val resChildren = this.flatMap { it.children }.distinct()
-        val contentChildren = this.filterIsInstance<ContentPage>()
-        val dri = contentChildren.flatMap { it.dri }.toSet()
-        val dci = DCI(
-            dri = dri,
-            kind = contentChildren.first().content.dci.kind
-        )
-        return contentChildren.first()
-            .modified(
-                dri = dri,
-                name = k,
-                children = resChildren,
-                content = asGroup(dci, contentChildren.map { it.content })
-            )
-    }
+    private fun tryMerge(strategy: PageMergerStrategy, pages: List<PageNode>) = if (pages.size > 1)
+        strategy.tryMerge(pages)
+    else
+        pages
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt
new file mode 100644
index 00000000..37dc5a6a
--- /dev/null
+++ b/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.dokka.transformers.pages
+
+import org.jetbrains.dokka.pages.PageNode
+
+abstract class PageMergerStrategy {
+
+    abstract fun tryMerge(pages: List<PageNode>): List<PageNode>
+
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt b/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
index 45357060..ebf53d30 100644
--- a/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
+++ b/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
@@ -4,6 +4,6 @@ import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 
-interface PageNodeTransformer {
-    operator fun invoke(input: RootPageNode): RootPageNode
+abstract class PageNodeTransformer(context: DokkaContext? = null) {
+    abstract operator fun invoke(input: RootPageNode): RootPageNode
 }
\ No newline at end of file
diff --git a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
index 52723157..0f66c77c 100644
--- a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
+++ b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
@@ -18,7 +18,7 @@ class MathjaxPlugin : DokkaPlugin() {
 private const val ANNOTATION = "usesMathJax"
 private const val LIB_PATH = "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.6/MathJax.js?config=TeX-AMS_SVG&latest"
 
-object MathjaxTransformer : PageNodeTransformer {
+object MathjaxTransformer : PageNodeTransformer() {
     override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
         it.modified(
             embeddedResources = it.embeddedResources + if (it.isNeedingMathjax) listOf(LIB_PATH) else emptyList()
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index e19b76b3..e2ac261a 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -16,7 +16,7 @@ class XmlPlugin : DokkaPlugin() {
     }
 }
 
-class XmlTransformer(private val dokkaContext: DokkaContext) : PageNodeTransformer {
+class XmlTransformer(private val dokkaContext: DokkaContext) : PageNodeTransformer(dokkaContext) {
     private val commentsToContentConverter by lazy { dokkaContext.single(CoreExtensions.commentsToContentConverter) }
 
     enum class XMLKind : Kind {
-- 
cgit 


From 519bc7969930f191fb7d9155b1c07f7e226e219f Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Tue, 11 Feb 2020 18:29:19 +0100
Subject: page merger strategy with tests

---
 .../main/kotlin/plugability/DefaultExtensions.kt   |   3 +-
 .../kotlin/renderers/html/htmlPreprocessors.kt     |  10 +-
 .../pages/DefaultPageMergerStrategy.kt             |  31 +----
 .../transformers/pages/DefaultPageNodeMerger.kt    |   2 +-
 .../transformers/pages/PageMergerStrategy.kt       |   4 +-
 .../transformers/pages/PageNodeTransformer.kt      |   4 +-
 .../pages/SameNamePageMergerStrategy.kt            |  30 +++++
 .../kotlin/pageMerger/DefaultPageNodeMergerTest.kt |  51 --------
 .../test/kotlin/pageMerger/PageNodeMergerTest.kt   | 128 +++++++++++++++++++++
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt   |   2 +-
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |   2 +-
 11 files changed, 178 insertions(+), 89 deletions(-)
 create mode 100644 core/src/main/kotlin/transformers/pages/SameNamePageMergerStrategy.kt
 delete mode 100644 core/src/test/kotlin/pageMerger/DefaultPageNodeMergerTest.kt
 create mode 100644 core/src/test/kotlin/pageMerger/PageNodeMergerTest.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 3f630ee3..28753cc6 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -10,6 +10,7 @@ import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumenta
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
+import org.jetbrains.dokka.transformers.pages.SameNamePageMergerStrategy
 import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageNodeMerger
 
@@ -37,7 +38,7 @@ internal object DefaultExtensions {
             CoreExtensions.renderer -> renderer.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
             CoreExtensions.outputWriter ->  outputWriter.get(fullContext)
-            CoreExtensions.pageMergerStrategy -> DefaultPageMergerStrategy
+            CoreExtensions.pageMergerStrategy -> DefaultPageMergerStrategy(fullContext.logger)
             else -> null
         }.let { listOfNotNull( it ) as List<T> }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
index 7ce6d298..4ee67448 100644
--- a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
+++ b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -8,12 +8,12 @@ import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.renderers.platforms
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
-object RootCreator : PageNodeTransformer() {
+object RootCreator : PageNodeTransformer {
     override fun invoke(input: RootPageNode) =
         RendererSpecificRootPage("", listOf(input), RenderingStrategy.DoNothing)
 }
 
-object SearchPageInstaller : PageNodeTransformer() {
+object SearchPageInstaller : PageNodeTransformer {
     override fun invoke(input: RootPageNode) = input.modified(children = input.children + searchPage)
 
     private val searchPage = RendererSpecificResourcePage(
@@ -34,7 +34,7 @@ object SearchPageInstaller : PageNodeTransformer() {
         })
 }
 
-object NavigationPageInstaller : PageNodeTransformer() {
+object NavigationPageInstaller : PageNodeTransformer {
     override fun invoke(input: RootPageNode) = input.modified(
         children = input.children + NavigationPage(
             input.children.filterIsInstance<ContentPage>().single().let(::visit)
@@ -48,7 +48,7 @@ object NavigationPageInstaller : PageNodeTransformer() {
         page.children.filterIsInstance<ContentPage>().map { visit(it) })
 }
 
-object ResourceInstaller : PageNodeTransformer() {
+object ResourceInstaller : PageNodeTransformer {
     override fun invoke(input: RootPageNode) = input.modified(children = input.children + resourcePages)
 
     private val resourcePages = listOf("styles", "scripts", "images").map {
@@ -56,7 +56,7 @@ object ResourceInstaller : PageNodeTransformer() {
     }
 }
 
-object StyleAndScriptsAppender : PageNodeTransformer() {
+object StyleAndScriptsAppender : PageNodeTransformer {
     override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
         it.modified(
             embeddedResources = it.embeddedResources + listOf(
diff --git a/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
index 81da71ce..66562d8b 100644
--- a/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
+++ b/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
@@ -1,30 +1,11 @@
 package org.jetbrains.dokka.transformers.pages
 
-import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.utilities.DokkaLogger
 
-object DefaultPageMergerStrategy : PageMergerStrategy() {
-    override fun tryMerge(pages: List<PageNode>): List<PageNode> = listOf(pages.mergePageNodes())
-
-    private fun List<PageNode>.mergePageNodes(): ContentPage {
-        val name = first().name
-        val resChildren = this.flatMap { it.children }.distinct()
-        val contentChildren = this.filterIsInstance<ContentPage>()
-        val dri = contentChildren.flatMap { it.dri }.toSet()
-        val dci = DCI(
-            dri = dri,
-            kind = contentChildren.first().content.dci.kind
-        )
-        return contentChildren.first()
-            .modified(
-                dri = dri,
-                name = name,
-                children = resChildren,
-                content = asGroup(dci, contentChildren.map { it.content })
-            )
-    }
-
-    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
-        val n = nodes.first()
-        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
+class DefaultPageMergerStrategy(val logger: DokkaLogger) : PageMergerStrategy {
+    override fun tryMerge(pages: List<PageNode>): List<PageNode> {
+        if (pages.size != 1) logger.warn("Expected 1 page, but got ${pages.size}")
+        return listOf(pages.first())
     }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt b/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
index 72e491cf..bdfe393e 100644
--- a/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
@@ -5,7 +5,7 @@ import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 
-class DefaultPageNodeMerger(val context: DokkaContext) : PageNodeTransformer(context) {
+class DefaultPageNodeMerger(val context: DokkaContext) : PageNodeTransformer {
     override fun invoke(input: RootPageNode): RootPageNode =
         input.modified(children = input.children.map { it.mergeChildren() })
 
diff --git a/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt
index 37dc5a6a..8eb526b3 100644
--- a/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt
+++ b/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt
@@ -2,8 +2,8 @@ package org.jetbrains.dokka.transformers.pages
 
 import org.jetbrains.dokka.pages.PageNode
 
-abstract class PageMergerStrategy {
+interface PageMergerStrategy {
 
-    abstract fun tryMerge(pages: List<PageNode>): List<PageNode>
+    fun tryMerge(pages: List<PageNode>): List<PageNode>
 
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt b/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
index ebf53d30..45357060 100644
--- a/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
+++ b/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
@@ -4,6 +4,6 @@ import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 
-abstract class PageNodeTransformer(context: DokkaContext? = null) {
-    abstract operator fun invoke(input: RootPageNode): RootPageNode
+interface PageNodeTransformer {
+    operator fun invoke(input: RootPageNode): RootPageNode
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/SameNamePageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/SameNamePageMergerStrategy.kt
new file mode 100644
index 00000000..5b0e8794
--- /dev/null
+++ b/core/src/main/kotlin/transformers/pages/SameNamePageMergerStrategy.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.dokka.transformers.pages
+
+import org.jetbrains.dokka.pages.*
+
+object SameNamePageMergerStrategy : PageMergerStrategy {
+    override fun tryMerge(pages: List<PageNode>): List<PageNode> = listOf(pages.mergePageNodes())
+
+    private fun List<PageNode>.mergePageNodes(): ContentPage {
+        val name = first().name
+        val resChildren = this.flatMap { it.children }.distinct()
+        val contentChildren = this.filterIsInstance<ContentPage>()
+        val dri = contentChildren.flatMap { it.dri }.toSet()
+        val dci = DCI(
+            dri = dri,
+            kind = contentChildren.first().content.dci.kind
+        )
+        return contentChildren.first()
+            .modified(
+                dri = dri,
+                name = name,
+                children = resChildren,
+                content = asGroup(dci, contentChildren.map { it.content })
+            )
+    }
+
+    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
+        val n = nodes.first()
+        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
+    }
+}
\ No newline at end of file
diff --git a/core/src/test/kotlin/pageMerger/DefaultPageNodeMergerTest.kt b/core/src/test/kotlin/pageMerger/DefaultPageNodeMergerTest.kt
deleted file mode 100644
index 432820af..00000000
--- a/core/src/test/kotlin/pageMerger/DefaultPageNodeMergerTest.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-package pageMerger
-
-import org.jetbrains.dokka.pages.ContentPage
-import org.jetbrains.dokka.pages.PageNode
-import org.junit.Test
-import testApi.testRunner.AbstractCoreTest
-
-class DefaultPageNodeMergerTest : AbstractCoreTest() {
-
-    @Test
-    fun test1() {
-        val configuration = dokkaConfiguration {
-            passes {
-                pass {
-                    sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
-                }
-            }
-        }
-
-        testInline(
-            """
-            |/src/main/kotlin/pageMerger/Test.kt
-            |package pageMerger
-            |
-            |fun testT(): Int = 1
-            |fun testT(i: Int): Int = i
-            |
-            |object Test {
-            |   fun test(): String = ""
-            |   fun test(str: String): String = str
-            |}
-        """.trimMargin(),
-            configuration
-        ) {
-            pagesTransformationStage = {
-                val allChildren = it.childrenRec().filterIsInstance<ContentPage>()
-                val testT = allChildren.filter { it.name == "testT" }
-                val test = allChildren.filter { it.name == "test" }
-
-                assert(testT.size == 1) { "There can be only one testT page" }
-                assert(testT.first().dri.size == 2) { "testT page should have 2 DRI" }
-
-                assert(test.size == 1) { "There can be only one test page" }
-                assert(test.first().dri.size == 2) { "test page should have 2 DRI" }
-            }
-        }
-    }
-
-    fun PageNode.childrenRec(): List<PageNode> = listOf(this) + children.flatMap { it.childrenRec() }
-
-}
\ No newline at end of file
diff --git a/core/src/test/kotlin/pageMerger/PageNodeMergerTest.kt b/core/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
new file mode 100644
index 00000000..e43e2348
--- /dev/null
+++ b/core/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
@@ -0,0 +1,128 @@
+package pageMerger
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
+import org.jetbrains.dokka.transformers.pages.PageMergerStrategy
+import org.jetbrains.dokka.transformers.pages.SameNamePageMergerStrategy
+import org.jetbrains.dokka.utilities.DokkaLogger
+import org.junit.Test
+import testApi.testRunner.AbstractCoreTest
+
+class PageNodeMergerTest : AbstractCoreTest() {
+
+    object SameNameStrategy : DokkaPlugin() {
+        val strategy by extending { CoreExtensions.pageMergerStrategy with SameNamePageMergerStrategy }
+    }
+
+    class DefaultStrategy(val strList: MutableList<String> = mutableListOf()) : DokkaPlugin(), DokkaLogger {
+        val strategy by extending { CoreExtensions.pageMergerStrategy with DefaultPageMergerStrategy(this@DefaultStrategy) }
+
+        override var warningsCount: Int = 0
+        override var errorsCount: Int = 0
+
+        override fun debug(message: String) = TODO()
+
+        override fun info(message: String) = TODO()
+
+        override fun progress(message: String) = TODO()
+
+        override fun warn(message: String) {
+            strList += message
+        }
+
+        override fun error(message: String) = TODO()
+
+        override fun report() = TODO()
+    }
+
+    @Test
+    fun sameNameStrategyTest() {
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/pageMerger/Test.kt
+            |package pageMerger
+            |
+            |fun testT(): Int = 1
+            |fun testT(i: Int): Int = i
+            |
+            |object Test {
+            |   fun test(): String = ""
+            |   fun test(str: String): String = str
+            |}
+        """.trimMargin(),
+            configuration,
+            pluginOverrides = listOf(SameNameStrategy)
+        ) {
+            pagesTransformationStage = {
+                val allChildren = it.childrenRec().filterIsInstance<ContentPage>()
+                val testT = allChildren.filter { it.name == "testT" }
+                val test = allChildren.filter { it.name == "test" }
+
+                assert(testT.size == 1) { "There can be only one testT page" }
+                assert(testT.first().dri.size == 2) { "testT page should have 2 DRI, but has ${testT.first().dri.size}" }
+
+                assert(test.size == 1) { "There can be only one test page" }
+                assert(test.first().dri.size == 2) { "test page should have 2 DRI, but has ${test.first().dri.size}" }
+            }
+        }
+    }
+
+    @Test
+    fun defaultStrategyTest() {
+        val strList: MutableList<String> = mutableListOf()
+
+        val configuration = dokkaConfiguration {
+            passes {
+                pass {
+                    sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
+                }
+            }
+        }
+
+        testInline(
+            """
+            |/src/main/kotlin/pageMerger/Test.kt
+            |package pageMerger
+            |
+            |fun testT(): Int = 1
+            |fun testT(i: Int): Int = i
+            |
+            |object Test {
+            |   fun test(): String = ""
+            |   fun test(str: String): String = str
+            |}
+        """.trimMargin(),
+            configuration,
+            pluginOverrides = listOf(DefaultStrategy(strList))
+        ) {
+            pagesTransformationStage = { root ->
+                val allChildren = root.childrenRec().filterIsInstance<ContentPage>()
+                val testT = allChildren.filter { it.name == "testT" }
+                val test = allChildren.filter { it.name == "test" }
+
+                assert(testT.size == 1) { "There can be only one testT page" }
+                assert(testT.first().dri.size == 1) { "testT page should have single DRI, but has ${testT.first().dri.size}" }
+
+                assert(test.size == 1) { "There can be only one test page" }
+                assert(test.first().dri.size == 1) { "test page should have single DRI, but has ${test.first().dri.size}" }
+
+                assert(strList.count() == 2) { "Expected 2 warnings, got ${strList.count()}" }
+            }
+        }
+    }
+
+    fun PageNode.childrenRec(): List<PageNode> = listOf(this) + children.flatMap { it.childrenRec() }
+
+}
\ No newline at end of file
diff --git a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
index 0f66c77c..52723157 100644
--- a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
+++ b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
@@ -18,7 +18,7 @@ class MathjaxPlugin : DokkaPlugin() {
 private const val ANNOTATION = "usesMathJax"
 private const val LIB_PATH = "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.6/MathJax.js?config=TeX-AMS_SVG&latest"
 
-object MathjaxTransformer : PageNodeTransformer() {
+object MathjaxTransformer : PageNodeTransformer {
     override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
         it.modified(
             embeddedResources = it.embeddedResources + if (it.isNeedingMathjax) listOf(LIB_PATH) else emptyList()
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index e2ac261a..e19b76b3 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -16,7 +16,7 @@ class XmlPlugin : DokkaPlugin() {
     }
 }
 
-class XmlTransformer(private val dokkaContext: DokkaContext) : PageNodeTransformer(dokkaContext) {
+class XmlTransformer(private val dokkaContext: DokkaContext) : PageNodeTransformer {
     private val commentsToContentConverter by lazy { dokkaContext.single(CoreExtensions.commentsToContentConverter) }
 
     enum class XMLKind : Kind {
-- 
cgit 


From 199b69db4c1cb2cd90a2a190479082150235faf4 Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Wed, 12 Feb 2020 11:20:58 +0100
Subject: rename

---
 .../main/kotlin/plugability/DefaultExtensions.kt   |  1 -
 .../pages/SameMethodNamePageMergerStrategy.kt      | 33 ++++++++++++++++++++++
 .../pages/SameNamePageMergerStrategy.kt            | 33 ----------------------
 .../test/kotlin/pageMerger/PageNodeMergerTest.kt   |  5 ++--
 4 files changed, 35 insertions(+), 37 deletions(-)
 create mode 100644 core/src/main/kotlin/transformers/pages/SameMethodNamePageMergerStrategy.kt
 delete mode 100644 core/src/main/kotlin/transformers/pages/SameNamePageMergerStrategy.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 28753cc6..1320c282 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -10,7 +10,6 @@ import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumenta
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
-import org.jetbrains.dokka.transformers.pages.SameNamePageMergerStrategy
 import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageNodeMerger
 
diff --git a/core/src/main/kotlin/transformers/pages/SameMethodNamePageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/SameMethodNamePageMergerStrategy.kt
new file mode 100644
index 00000000..3835506b
--- /dev/null
+++ b/core/src/main/kotlin/transformers/pages/SameMethodNamePageMergerStrategy.kt
@@ -0,0 +1,33 @@
+package org.jetbrains.dokka.transformers.pages
+
+import org.jetbrains.dokka.pages.*
+
+object SameMethodNamePageMergerStrategy : PageMergerStrategy {
+    override fun tryMerge(pages: List<PageNode>): List<PageNode> {
+        val name = pages.first().name
+        val members = pages.filterIsInstance<MemberPageNode>()
+        val others = pages.filterNot { it is MemberPageNode }
+
+        val resChildren = members.flatMap { it.children }.distinct()
+        val dri = members.flatMap { it.dri }.toSet()
+        val dci = DCI(
+            dri = dri,
+            kind = members.first().content.dci.kind
+        )
+
+        val merged = MemberPageNode(
+            dri = dri,
+            name = name,
+            children = resChildren,
+            content = asGroup(dci, members.map { it.content }),
+            documentable = null
+        )
+
+        return others + listOf(merged)
+    }
+
+    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
+        val n = nodes.first()
+        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
+    }
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/SameNamePageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/SameNamePageMergerStrategy.kt
deleted file mode 100644
index 47d5a2f5..00000000
--- a/core/src/main/kotlin/transformers/pages/SameNamePageMergerStrategy.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package org.jetbrains.dokka.transformers.pages
-
-import org.jetbrains.dokka.pages.*
-
-object SameNamePageMergerStrategy : PageMergerStrategy {
-    override fun tryMerge(pages: List<PageNode>): List<PageNode> {
-        val name = pages.first().name
-        val members = pages.filterIsInstance<MemberPageNode>()
-        val others = pages.filterNot { it is MemberPageNode }
-
-        val resChildren = members.flatMap { it.children }.distinct()
-        val dri = members.flatMap { it.dri }.toSet()
-        val dci = DCI(
-            dri = dri,
-            kind = members.first().content.dci.kind
-        )
-
-        val merged = MemberPageNode(
-            dri = dri,
-            name = name,
-            children = resChildren,
-            content = asGroup(dci, members.map { it.content }),
-            documentable = null
-        )
-
-        return others + listOf(merged)
-    }
-
-    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
-        val n = nodes.first()
-        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
-    }
-}
\ No newline at end of file
diff --git a/core/src/test/kotlin/pageMerger/PageNodeMergerTest.kt b/core/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
index e43e2348..88e57ddb 100644
--- a/core/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
+++ b/core/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
@@ -5,8 +5,7 @@ import org.jetbrains.dokka.pages.ContentPage
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
-import org.jetbrains.dokka.transformers.pages.PageMergerStrategy
-import org.jetbrains.dokka.transformers.pages.SameNamePageMergerStrategy
+import org.jetbrains.dokka.transformers.pages.SameMethodNamePageMergerStrategy
 import org.jetbrains.dokka.utilities.DokkaLogger
 import org.junit.Test
 import testApi.testRunner.AbstractCoreTest
@@ -14,7 +13,7 @@ import testApi.testRunner.AbstractCoreTest
 class PageNodeMergerTest : AbstractCoreTest() {
 
     object SameNameStrategy : DokkaPlugin() {
-        val strategy by extending { CoreExtensions.pageMergerStrategy with SameNamePageMergerStrategy }
+        val strategy by extending { CoreExtensions.pageMergerStrategy with SameMethodNamePageMergerStrategy }
     }
 
     class DefaultStrategy(val strList: MutableList<String> = mutableListOf()) : DokkaPlugin(), DokkaLogger {
-- 
cgit 


From 848f2e0656e80604cb54932db5b250303aaccca8 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Wed, 12 Feb 2020 16:01:38 +0100
Subject: Moves DescriptorToDocumentableTransformer to base plugin

---
 core/src/main/kotlin/CoreExtensions.kt             |   1 -
 core/src/main/kotlin/DokkaGenerator.kt             |   2 +-
 core/src/main/kotlin/model/Documentable.kt         |  12 -
 core/src/main/kotlin/model/classKinds.kt           |  25 ++
 core/src/main/kotlin/model/typeWrappers.kt         |  97 ++++++
 .../main/kotlin/plugability/DefaultExtensions.kt   |   2 -
 .../DefaultDescriptorToDocumentationTranslator.kt  | 362 ---------------------
 .../DescriptorToDocumentationTranslator.kt         |   3 +-
 .../psi/DefaultPsiToDocumentationTranslator.kt     |  72 ----
 plugins/base/build.gradle.kts                      |   3 +-
 plugins/base/src/main/kotlin/DokkaBase.kt          |   7 +
 .../DefaultDescriptorToDocumentationTranslator.kt  | 338 +++++++++++++++++++
 plugins/kotlin-as-java/build.gradle.kts            |   4 +
 ...linAsJavaDescriptorToDocumentationTranslator.kt |  13 +-
 .../src/main/kotlin/KotlinAsJavaPageBuilder.kt     |   1 -
 .../main/kotlin/KotlinAsJavaPageContentBuilder.kt  |   2 +-
 .../src/main/kotlin/KotlinAsJavaPlugin.kt          |   8 +-
 .../src/main/kotlin/KotlinToJVMResolver.kt         |   1 -
 18 files changed, 489 insertions(+), 464 deletions(-)
 create mode 100644 core/src/main/kotlin/model/classKinds.kt
 create mode 100644 core/src/main/kotlin/model/typeWrappers.kt
 delete mode 100644 core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 18cde210..1364f1c1 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -30,7 +30,6 @@ object CoreExtensions {
     val locationProviderFactory by coreExtension<LocationProviderFactory>()
     val outputWriter by coreExtension<OutputWriter>()
     val renderer by coreExtension<Renderer>()
-    val fileExtension by coreExtension<String>()
     val pageMergerStrategy by coreExtension<PageMergerStrategy>()
 
     private fun <T: Any> coreExtension() = object {
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index a31c04a6..6a21e031 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -130,7 +130,7 @@ class DokkaGenerator(
             .toList()
 
         return context.single(CoreExtensions.descriptorToDocumentationTranslator)
-            .invoke(platformData.name, packageFragments, platformData, context)
+            .invoke(platformData.name, packageFragments, platformData)
     }
 
     private fun translatePsi(platformData: PlatformData, context: DokkaContext): Module {
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index e64f82ac..f0820256 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -3,9 +3,6 @@ package org.jetbrains.dokka.model
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.dokka.transformers.descriptors.KotlinClassKindTypes
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 
 class Module(override val name: String, val packages: List<Package>) : Documentable() {
@@ -239,15 +236,6 @@ private fun String.shorten(maxLength: Int) = lineSequence().first().let {
     if (it.length != length || it.length > maxLength) it.take(maxLength - 3) + "..." else it
 }
 
-interface TypeWrapper {
-    val constructorFqName: String?
-    val constructorNamePathSegments: List<String>
-    val arguments: List<TypeWrapper>
-    val dri: DRI?
-}
-
-interface ClassKind
-
 fun Documentable.dfs(predicate: (Documentable) -> Boolean): Documentable? =
     if (predicate(this)) {
         this
diff --git a/core/src/main/kotlin/model/classKinds.kt b/core/src/main/kotlin/model/classKinds.kt
new file mode 100644
index 00000000..2548f68d
--- /dev/null
+++ b/core/src/main/kotlin/model/classKinds.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.dokka.model
+
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+import org.jetbrains.kotlin.types.KotlinType
+
+
+interface ClassKind
+
+enum class KotlinClassKindTypes : ClassKind {
+    CLASS,
+    INTERFACE,
+    ENUM_CLASS,
+    ENUM_ENTRY,
+    ANNOTATION_CLASS,
+    OBJECT;
+}
+
+enum class JavaClassKindTypes : ClassKind {
+    CLASS,
+    INTERFACE,
+    ENUM_CLASS,
+    ENUM_ENTRY,
+    ANNOTATION_CLASS;
+}
diff --git a/core/src/main/kotlin/model/typeWrappers.kt b/core/src/main/kotlin/model/typeWrappers.kt
new file mode 100644
index 00000000..5719c6d3
--- /dev/null
+++ b/core/src/main/kotlin/model/typeWrappers.kt
@@ -0,0 +1,97 @@
+package org.jetbrains.dokka.model
+
+import com.intellij.psi.PsiArrayType
+import com.intellij.psi.PsiEllipsisType
+import com.intellij.psi.PsiPrimitiveType
+import com.intellij.psi.PsiType
+import com.intellij.psi.impl.source.PsiClassReferenceType
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+import org.jetbrains.kotlin.types.KotlinType
+
+interface TypeWrapper {
+    val constructorFqName: String?
+    val constructorNamePathSegments: List<String>
+    val arguments: List<TypeWrapper>
+    val dri: DRI?
+}
+
+class KotlinTypeWrapper(private val kotlinType: KotlinType) : TypeWrapper {
+    private val declarationDescriptor = kotlinType.constructor.declarationDescriptor
+    private val fqNameSafe = declarationDescriptor?.fqNameSafe
+    override val constructorFqName = fqNameSafe?.asString()
+    override val constructorNamePathSegments: List<String> =
+        fqNameSafe?.pathSegments()?.map { it.asString() } ?: emptyList()
+    override val arguments: List<KotlinTypeWrapper> by lazy {
+        kotlinType.arguments.map {
+            KotlinTypeWrapper(
+                it.type
+            )
+        }
+    }
+    override val dri: DRI? by lazy { declarationDescriptor?.let { DRI.from(it) } }
+}
+
+class JavaTypeWrapper : TypeWrapper {
+
+    override val constructorFqName: String?
+    override val constructorNamePathSegments: List<String>
+    override val arguments: List<TypeWrapper>
+    override val dri: DRI?
+    val isPrimitive: Boolean
+
+    constructor(
+        constructorNamePathSegments: List<String>,
+        arguments: List<TypeWrapper>,
+        dri: DRI?,
+        isPrimitiveType: Boolean
+    ) {
+        this.constructorFqName = constructorNamePathSegments.joinToString(".")
+        this.constructorNamePathSegments = constructorNamePathSegments
+        this.arguments = arguments
+        this.dri = dri
+        this.isPrimitive = isPrimitiveType
+    }
+
+    constructor(type: PsiType) {
+        if (type is PsiClassReferenceType) {
+            val resolved = type.resolve()
+            constructorFqName = resolved?.qualifiedName
+            constructorNamePathSegments = resolved?.qualifiedName?.split('.') ?: emptyList()
+            arguments = type.parameters.mapNotNull {
+                if (it is PsiClassReferenceType) JavaTypeWrapper(it) else null
+            }
+            dri = fromPsi(type)
+            this.isPrimitive = false
+        } else if (type is PsiEllipsisType) {
+            constructorFqName = type.canonicalText
+            constructorNamePathSegments = listOf(type.canonicalText) // TODO
+            arguments = emptyList()
+            dri = DRI("java.lang", "Object") // TODO
+            this.isPrimitive = false
+        } else if (type is PsiArrayType) {
+            constructorFqName = type.canonicalText
+            constructorNamePathSegments = listOf(type.canonicalText)
+            arguments = emptyList()
+            dri = (type as? PsiClassReferenceType)?.let { fromPsi(it) } // TODO
+            this.isPrimitive = false
+        } else {
+            type as PsiPrimitiveType
+            constructorFqName = type.name
+            constructorNamePathSegments = type.name.split('.')
+            arguments = emptyList()
+            dri = null
+            this.isPrimitive = true
+        }
+    }
+
+    private fun fromPsi(type: PsiClassReferenceType): DRI {
+        val className = type.className
+        val pkg = type.canonicalText.removeSuffix(className).removeSuffix(".")
+        return DRI(packageName = pkg, classNames = className)
+    }
+
+    override fun toString(): String {
+        return constructorFqName.orEmpty()
+    }
+}
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 1320c282..70a7e4db 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -6,7 +6,6 @@ import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.OutputWriter
 import org.jetbrains.dokka.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
-import org.jetbrains.dokka.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
@@ -28,7 +27,6 @@ internal object DefaultExtensions {
     @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
-            CoreExtensions.descriptorToDocumentationTranslator ->  DefaultDescriptorToDocumentationTranslator
             CoreExtensions.psiToDocumentationTranslator -> DefaultPsiToDocumentationTranslator
             CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
             CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
diff --git a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
deleted file mode 100644
index 173e13ac..00000000
--- a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
+++ /dev/null
@@ -1,362 +0,0 @@
-package org.jetbrains.dokka.transformers.descriptors
-
-import org.jetbrains.dokka.analysis.DokkaResolutionFacade
-import org.jetbrains.dokka.links.Callable
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.links.withClass
-import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.model.ClassKind
-import org.jetbrains.dokka.model.Enum
-import org.jetbrains.dokka.model.Function
-import org.jetbrains.dokka.model.Property
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.dokka.parsers.MarkdownParser
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
-import org.jetbrains.kotlin.idea.kdoc.findKDoc
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
-import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.types.KotlinType
-import kotlin.reflect.KClass
-
-object DefaultDescriptorToDocumentationTranslator : DescriptorToDocumentationTranslator {
-    override fun invoke(
-        moduleName: String,
-        packageFragments: Iterable<PackageFragmentDescriptor>,
-        platformData: PlatformData,
-        context: DokkaContext
-    ) = DokkaDescriptorVisitor(platformData, context.platforms[platformData]?.facade!!).run {
-        packageFragments.map {
-            visitPackageFragmentDescriptor(
-                it,
-                DRIWithPlatformInfo(DRI.topLevel, null, emptyList())
-            )
-        }
-    }.let { Module(moduleName, it) }
-
-}
-
-
-data class DRIWithPlatformInfo(
-    val dri: DRI,
-    val expected: PlatformInfo?,
-    val actual: List<PlatformInfo>
-)
-
-fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, null, emptyList())
-
-open class DokkaDescriptorVisitor(
-    private val platformData: PlatformData,
-    private val resolutionFacade: DokkaResolutionFacade
-) : DeclarationDescriptorVisitorEmptyBodies<Documentable, DRIWithPlatformInfo>() {
-    override fun visitDeclarationDescriptor(descriptor: DeclarationDescriptor, parent: DRIWithPlatformInfo): Nothing {
-        throw IllegalStateException("${javaClass.simpleName} should never enter ${descriptor.javaClass.simpleName}")
-    }
-
-    override fun visitPackageFragmentDescriptor(
-        descriptor: PackageFragmentDescriptor,
-        parent: DRIWithPlatformInfo
-    ): Package {
-        val driWithPlatform = DRI(packageName = descriptor.fqName.asString()).withEmptyInfo()
-        val scope = descriptor.getMemberScope()
-
-        return Package(
-            dri = driWithPlatform.dri,
-            functions = scope.functions(driWithPlatform),
-            properties = scope.properties(driWithPlatform),
-            classlikes = scope.classlikes(driWithPlatform)
-        )
-    }
-
-    override fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Classlike =
-        when (descriptor.kind) {
-            org.jetbrains.kotlin.descriptors.ClassKind.ENUM_CLASS -> enumDescriptor(descriptor, parent)
-            else -> classDescriptor(descriptor, parent)
-        }
-
-    fun enumDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Enum {
-        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
-        val scope = descriptor.unsubstitutedMemberScope
-        val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
-
-        return Enum(
-            dri = driWithPlatform.dri,
-            name = descriptor.name.asString(),
-            entries = scope.classlikes(driWithPlatform).filter { it.kind == KotlinClassKindTypes.ENUM_ENTRY }.map {
-                EnumEntry(
-                    it
-                )
-            },
-            constructors = descriptor.constructors.map { visitConstructorDescriptor(it, driWithPlatform) },
-            functions = scope.functions(driWithPlatform),
-            properties = scope.properties(driWithPlatform),
-            classlikes = scope.classlikes(driWithPlatform),
-            expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData(),
-            actual = listOfNotNull(descriptorData),
-            extra = mutableSetOf(), // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet()
-            visibility = mapOf(platformData to descriptor.visibility)
-        )
-    }
-
-    fun classDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Class {
-        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
-        val scope = descriptor.unsubstitutedMemberScope
-        val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
-        val expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData()
-        val actual = listOfNotNull(descriptorData)
-        return Class(
-            dri = driWithPlatform.dri,
-            name = descriptor.name.asString(),
-            kind = KotlinClassKindTypes.valueOf(descriptor.kind.toString()),
-            constructors = descriptor.constructors.map {
-                visitConstructorDescriptor(
-                    it,
-                    if (it.isPrimary)
-                        DRIWithPlatformInfo(
-                            driWithPlatform.dri,
-                            expected?.info.filterTagWrappers(listOf(Constructor::class)),
-                            actual.filterTagWrappers(listOf(Constructor::class))
-                        )
-                    else
-                        DRIWithPlatformInfo(driWithPlatform.dri, null, emptyList())
-                )
-            },
-            functions = scope.functions(driWithPlatform),
-            properties = scope.properties(driWithPlatform),
-            classlikes = scope.classlikes(driWithPlatform),
-            expected = expected,
-            actual = actual,
-            extra = mutableSetOf(), // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet()
-            visibility = mapOf(platformData to descriptor.visibility)
-        )
-    }
-
-    override fun visitPropertyDescriptor(descriptor: PropertyDescriptor, parent: DRIWithPlatformInfo): Property {
-        val expected = descriptor.takeIf { it.isExpect }?.resolveDescriptorData()
-        val actual = listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
-        val dri = parent.dri.copy(callable = Callable.from(descriptor))
-
-        return Property(
-            dri = dri,
-            name = descriptor.name.asString(),
-            receiver = descriptor.extensionReceiverParameter?.let {
-                visitReceiverParameterDescriptor(
-                    it,
-                    DRIWithPlatformInfo(
-                        dri,
-                        expected?.filterTagWrappers(listOf(Receiver::class)),
-                        actual.filterTagWrappers(listOf(Receiver::class))
-                    )
-                )
-            },
-            expected = expected,
-            actual = actual,
-            accessors = descriptor.accessors.map { visitPropertyAccessorDescriptor(it, descriptor, dri) },
-            visibility = mapOf(platformData to descriptor.visibility)
-        )
-    }
-
-    override fun visitFunctionDescriptor(descriptor: FunctionDescriptor, parent: DRIWithPlatformInfo): Function {
-        val expected = descriptor.takeIf { it.isExpect }?.resolveDescriptorData()
-        val actual = listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
-        val dri = parent.dri.copy(callable = Callable.from(descriptor))
-
-        return Function(
-            dri = dri,
-            name = descriptor.name.asString(),
-            returnType = descriptor.returnType?.let { KotlinTypeWrapper(it) },
-            isConstructor = false,
-            receiver = descriptor.extensionReceiverParameter?.let {
-                visitReceiverParameterDescriptor(
-                    it,
-                    DRIWithPlatformInfo(
-                        dri,
-                        expected?.filterTagWrappers(listOf(Receiver::class)),
-                        actual.filterTagWrappers(listOf(Receiver::class))
-                    )
-                )
-            },
-            parameters = descriptor.valueParameters.mapIndexed { index, desc ->
-                parameter(
-                    index, desc,
-                    DRIWithPlatformInfo(
-                        dri,
-                        expected.filterTagWrappers(listOf(Param::class), desc.name.asString()),
-                        actual.filterTagWrappers(listOf(Param::class), desc.name.asString())
-                    )
-                )
-            },
-            expected = expected,
-            actual = actual,
-            visibility = mapOf(platformData to descriptor.visibility)
-        )
-    }
-
-    override fun visitConstructorDescriptor(descriptor: ConstructorDescriptor, parent: DRIWithPlatformInfo): Function {
-        val dri = parent.dri.copy(callable = Callable.from(descriptor))
-        return Function(
-            dri = dri,
-            name = "<init>",
-            returnType = KotlinTypeWrapper(descriptor.returnType),
-            isConstructor = true,
-            receiver = null,
-            parameters = descriptor.valueParameters.mapIndexed { index, desc ->
-                parameter(
-                    index, desc,
-                    DRIWithPlatformInfo(
-                        dri,
-                        parent.expected.filterTagWrappers(listOf(Param::class)),
-                        parent.actual.filterTagWrappers(listOf(Param::class))
-                    )
-                )
-            },
-            expected = parent.expected ?: descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
-            actual = parent.actual,
-            visibility = mapOf(platformData to descriptor.visibility)
-        )
-    }
-
-    override fun visitReceiverParameterDescriptor(
-        descriptor: ReceiverParameterDescriptor,
-        parent: DRIWithPlatformInfo
-    ) = Parameter(
-        dri = parent.dri.copy(target = 0),
-        name = null,
-        type = KotlinTypeWrapper(descriptor.type),
-        expected = parent.expected,
-        actual = parent.actual
-    )
-
-    open fun visitPropertyAccessorDescriptor(
-        descriptor: PropertyAccessorDescriptor,
-        propertyDescriptor: PropertyDescriptor,
-        parent: DRI
-    ): Function {
-        val dri = parent.copy(callable = Callable.from(descriptor))
-        val isGetter = descriptor is PropertyGetterDescriptor
-
-        fun PropertyDescriptor.asParameter(parent: DRI) =
-            Parameter(
-                parent.copy(target = 1),
-                this.name.asString(),
-                KotlinTypeWrapper(this.type),
-                descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
-                listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
-            )
-
-        val name = run {
-            val modifier = if (isGetter) "get" else "set"
-            val rawName = propertyDescriptor.name.asString()
-            "$modifier${rawName[0].toUpperCase()}${rawName.drop(1)}"
-        }
-
-        descriptor.visibility
-        val parameters =
-            if (isGetter) {
-                emptyList()
-            } else {
-                listOf(propertyDescriptor.asParameter(dri))
-            }
-
-        return Function(
-            dri,
-            name,
-            descriptor.returnType?.let { KotlinTypeWrapper(it) },
-            false,
-            null,
-            parameters,
-            descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
-            listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData()),
-            visibility = mapOf(platformData to descriptor.visibility)
-        )
-    }
-
-    private fun parameter(index: Int, descriptor: ValueParameterDescriptor, parent: DRIWithPlatformInfo) =
-        Parameter(
-            dri = parent.dri.copy(target = index + 1),
-            name = descriptor.name.asString(),
-            type = KotlinTypeWrapper(descriptor.type),
-            expected = parent.expected,
-            actual = parent.actual
-        )
-
-    private fun MemberScope.functions(parent: DRIWithPlatformInfo): List<Function> =
-        getContributedDescriptors(DescriptorKindFilter.FUNCTIONS) { true }
-            .filterIsInstance<FunctionDescriptor>()
-            .map { visitFunctionDescriptor(it, parent) }
-
-    private fun MemberScope.properties(parent: DRIWithPlatformInfo): List<Property> =
-        getContributedDescriptors(DescriptorKindFilter.VALUES) { true }
-            .filterIsInstance<PropertyDescriptor>()
-            .map { visitPropertyDescriptor(it, parent) }
-
-    private fun MemberScope.classlikes(parent: DRIWithPlatformInfo): List<Classlike> =
-        getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) { true }
-            .filterIsInstance<ClassDescriptor>()
-            .map { visitClassDescriptor(it, parent) }
-
-    private fun DeclarationDescriptor.resolveDescriptorData(): PlatformInfo {
-        val doc = findKDoc()
-        val parser: MarkdownParser = MarkdownParser(resolutionFacade, this)
-        val docHeader = parser.parseFromKDocTag(doc)
-
-        return BasePlatformInfo(docHeader, listOf(platformData))
-    }
-
-    private fun ClassDescriptor.resolveClassDescriptionData(): ClassPlatformInfo {
-        return ClassPlatformInfo(resolveDescriptorData(),
-            (getSuperInterfaces() + getAllSuperclassesWithoutAny()).map { DRI.from(it) })
-    }
-
-    private fun PlatformInfo?.filterTagWrappers(
-        types: List<KClass<out TagWrapper>>,
-        name: String? = null
-    ): PlatformInfo? {
-        if (this == null)
-            return null
-        return BasePlatformInfo(
-            DocumentationNode(
-                this.documentationNode.children.filter { it::class in types && (it as? NamedTagWrapper)?.name == name }
-            ),
-            this.platformData
-        )
-    }
-
-    private fun List<PlatformInfo>.filterTagWrappers(
-        types: List<KClass<out TagWrapper>>,
-        name: String? = null
-    ): List<PlatformInfo> =
-        this.map { it.filterTagWrappers(types, name)!! }
-}
-
-data class XMLMega(val key: String, val dri: DRI) : Extra
-
-enum class KotlinClassKindTypes : ClassKind {
-    CLASS,
-    INTERFACE,
-    ENUM_CLASS,
-    ENUM_ENTRY,
-    ANNOTATION_CLASS,
-    OBJECT;
-}
-
-class KotlinTypeWrapper(private val kotlinType: KotlinType) : TypeWrapper {
-    private val declarationDescriptor = kotlinType.constructor.declarationDescriptor
-    private val fqNameSafe = declarationDescriptor?.fqNameSafe
-    override val constructorFqName = fqNameSafe?.asString()
-    override val constructorNamePathSegments: List<String> =
-        fqNameSafe?.pathSegments()?.map { it.asString() } ?: emptyList()
-    override val arguments: List<KotlinTypeWrapper> by lazy {
-        kotlinType.arguments.map {
-            KotlinTypeWrapper(
-                it.type
-            )
-        }
-    }
-    override val dri: DRI? by lazy { declarationDescriptor?.let { DRI.from(it) } }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
index 61d636d6..5074833e 100644
--- a/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
+++ b/core/src/main/kotlin/transformers/descriptors/DescriptorToDocumentationTranslator.kt
@@ -9,7 +9,6 @@ interface DescriptorToDocumentationTranslator {
     fun invoke(
         moduleName: String,
         packageFragments: Iterable<PackageFragmentDescriptor>,
-        platformData: PlatformData,
-        context: DokkaContext
+        platformData: PlatformData
     ): Module
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
index 144f319f..055df0b2 100644
--- a/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
+++ b/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
@@ -141,75 +141,3 @@ object DefaultPsiToDocumentationTranslator : PsiToDocumentationTranslator {
         }
     }
 }
-
-enum class JavaClassKindTypes : ClassKind {
-    CLASS,
-    INTERFACE,
-    ENUM_CLASS,
-    ENUM_ENTRY,
-    ANNOTATION_CLASS;
-}
-
-class JavaTypeWrapper : TypeWrapper {
-
-    override val constructorFqName: String?
-    override val constructorNamePathSegments: List<String>
-    override val arguments: List<TypeWrapper>
-    override val dri: DRI?
-    val isPrimitive: Boolean
-
-    constructor(
-        constructorNamePathSegments: List<String>,
-        arguments: List<TypeWrapper>,
-        dri: DRI?,
-        isPrimitiveType: Boolean
-    ) {
-        this.constructorFqName = constructorNamePathSegments.joinToString(".")
-        this.constructorNamePathSegments = constructorNamePathSegments
-        this.arguments = arguments
-        this.dri = dri
-        this.isPrimitive = isPrimitiveType
-    }
-
-    constructor(type: PsiType) {
-        if (type is PsiClassReferenceType) {
-            val resolved = type.resolve()
-            constructorFqName = resolved?.qualifiedName
-            constructorNamePathSegments = resolved?.qualifiedName?.split('.') ?: emptyList()
-            arguments = type.parameters.mapNotNull {
-                if (it is PsiClassReferenceType) JavaTypeWrapper(it) else null
-            }
-            dri = fromPsi(type)
-            this.isPrimitive = false
-        } else if (type is PsiEllipsisType) {
-            constructorFqName = type.canonicalText
-            constructorNamePathSegments = listOf(type.canonicalText) // TODO
-            arguments = emptyList()
-            dri = DRI("java.lang", "Object") // TODO
-            this.isPrimitive = false
-        } else if (type is PsiArrayType) {
-            constructorFqName = type.canonicalText
-            constructorNamePathSegments = listOf(type.canonicalText)
-            arguments = emptyList()
-            dri = (type as? PsiClassReferenceType)?.let { fromPsi(it) } // TODO
-            this.isPrimitive = false
-        } else {
-            type as PsiPrimitiveType
-            constructorFqName = type.name
-            constructorNamePathSegments = type.name.split('.')
-            arguments = emptyList()
-            dri = null
-            this.isPrimitive = true
-        }
-    }
-
-    private fun fromPsi(type: PsiClassReferenceType): DRI {
-        val className = type.className
-        val pkg = type.canonicalText.removeSuffix(className).removeSuffix(".")
-        return DRI(packageName = pkg, classNames = className)
-    }
-
-    override fun toString(): String {
-        return constructorFqName.orEmpty()
-    }
-}
\ No newline at end of file
diff --git a/plugins/base/build.gradle.kts b/plugins/base/build.gradle.kts
index 386a3288..ba0b5753 100644
--- a/plugins/base/build.gradle.kts
+++ b/plugins/base/build.gradle.kts
@@ -5,4 +5,5 @@ publishing {
             from(components["java"])
         }
     }
-}
\ No newline at end of file
+}
+
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index e82a59bf..5c579e54 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -1,4 +1,11 @@
+package org.jetbrains.dokka.base
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.base.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.plugability.DokkaPlugin
 
 class DokkaBase: DokkaPlugin() {
+    val defaultDescriptorToDocumentationTranslator by extending {
+        CoreExtensions.descriptorToDocumentationTranslator providing ::DefaultDescriptorToDocumentationTranslator
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/plugins/base/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
new file mode 100644
index 00000000..1358cef1
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
@@ -0,0 +1,338 @@
+package org.jetbrains.dokka.base.transformers.descriptors
+
+import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+import org.jetbrains.dokka.links.Callable
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.links.withClass
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.ClassKind
+import org.jetbrains.dokka.model.Enum
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.model.Property
+import org.jetbrains.dokka.model.doc.*
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.parsers.MarkdownParser
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTranslator
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
+import org.jetbrains.kotlin.idea.kdoc.findKDoc
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
+import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.types.KotlinType
+import kotlin.reflect.KClass
+
+class DefaultDescriptorToDocumentationTranslator(
+    private val context: DokkaContext
+) : DescriptorToDocumentationTranslator {
+    override fun invoke(
+        moduleName: String,
+        packageFragments: Iterable<PackageFragmentDescriptor>,
+        platformData: PlatformData
+    ) = DokkaDescriptorVisitor(platformData, context.platforms[platformData]?.facade!!).run {
+        packageFragments.map {
+            visitPackageFragmentDescriptor(
+                it,
+                DRIWithPlatformInfo(DRI.topLevel, null, emptyList())
+            )
+        }
+    }.let { Module(moduleName, it) }
+
+}
+
+
+data class DRIWithPlatformInfo(
+    val dri: DRI,
+    val expected: PlatformInfo?,
+    val actual: List<PlatformInfo>
+)
+
+fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, null, emptyList())
+
+open class DokkaDescriptorVisitor( // TODO: close this class and make it private together with DRIWithPlatformInfo
+    private val platformData: PlatformData,
+    private val resolutionFacade: DokkaResolutionFacade
+) : DeclarationDescriptorVisitorEmptyBodies<Documentable, DRIWithPlatformInfo>() {
+    override fun visitDeclarationDescriptor(descriptor: DeclarationDescriptor, parent: DRIWithPlatformInfo): Nothing {
+        throw IllegalStateException("${javaClass.simpleName} should never enter ${descriptor.javaClass.simpleName}")
+    }
+
+    override fun visitPackageFragmentDescriptor(
+        descriptor: PackageFragmentDescriptor,
+        parent: DRIWithPlatformInfo
+    ): Package {
+        val driWithPlatform = DRI(packageName = descriptor.fqName.asString()).withEmptyInfo()
+        val scope = descriptor.getMemberScope()
+
+        return Package(
+            dri = driWithPlatform.dri,
+            functions = scope.functions(driWithPlatform),
+            properties = scope.properties(driWithPlatform),
+            classlikes = scope.classlikes(driWithPlatform)
+        )
+    }
+
+    override fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Classlike =
+        when (descriptor.kind) {
+            org.jetbrains.kotlin.descriptors.ClassKind.ENUM_CLASS -> enumDescriptor(descriptor, parent)
+            else -> classDescriptor(descriptor, parent)
+        }
+
+    fun enumDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Enum {
+        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
+        val scope = descriptor.unsubstitutedMemberScope
+        val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
+
+        return Enum(
+            dri = driWithPlatform.dri,
+            name = descriptor.name.asString(),
+            entries = scope.classlikes(driWithPlatform).filter { it.kind == KotlinClassKindTypes.ENUM_ENTRY }.map {
+                EnumEntry(
+                    it
+                )
+            },
+            constructors = descriptor.constructors.map { visitConstructorDescriptor(it, driWithPlatform) },
+            functions = scope.functions(driWithPlatform),
+            properties = scope.properties(driWithPlatform),
+            classlikes = scope.classlikes(driWithPlatform),
+            expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData(),
+            actual = listOfNotNull(descriptorData),
+            extra = mutableSetOf(), // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet()
+            visibility = mapOf(platformData to descriptor.visibility)
+        )
+    }
+
+    fun classDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Class {
+        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
+        val scope = descriptor.unsubstitutedMemberScope
+        val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
+        val expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData()
+        val actual = listOfNotNull(descriptorData)
+        return Class(
+            dri = driWithPlatform.dri,
+            name = descriptor.name.asString(),
+            kind = KotlinClassKindTypes.valueOf(descriptor.kind.toString()),
+            constructors = descriptor.constructors.map {
+                visitConstructorDescriptor(
+                    it,
+                    if (it.isPrimary)
+                        DRIWithPlatformInfo(
+                            driWithPlatform.dri,
+                            expected?.info.filterTagWrappers(listOf(Constructor::class)),
+                            actual.filterTagWrappers(listOf(Constructor::class))
+                        )
+                    else
+                        DRIWithPlatformInfo(driWithPlatform.dri, null, emptyList())
+                )
+            },
+            functions = scope.functions(driWithPlatform),
+            properties = scope.properties(driWithPlatform),
+            classlikes = scope.classlikes(driWithPlatform),
+            expected = expected,
+            actual = actual,
+            extra = mutableSetOf(), // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet()
+            visibility = mapOf(platformData to descriptor.visibility)
+        )
+    }
+
+    override fun visitPropertyDescriptor(descriptor: PropertyDescriptor, parent: DRIWithPlatformInfo): Property {
+        val expected = descriptor.takeIf { it.isExpect }?.resolveDescriptorData()
+        val actual = listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
+        val dri = parent.dri.copy(callable = Callable.from(descriptor))
+
+        return Property(
+            dri = dri,
+            name = descriptor.name.asString(),
+            receiver = descriptor.extensionReceiverParameter?.let {
+                visitReceiverParameterDescriptor(
+                    it,
+                    DRIWithPlatformInfo(
+                        dri,
+                        expected?.filterTagWrappers(listOf(Receiver::class)),
+                        actual.filterTagWrappers(listOf(Receiver::class))
+                    )
+                )
+            },
+            expected = expected,
+            actual = actual,
+            accessors = descriptor.accessors.map { visitPropertyAccessorDescriptor(it, descriptor, dri) },
+            visibility = mapOf(platformData to descriptor.visibility)
+        )
+    }
+
+    override fun visitFunctionDescriptor(descriptor: FunctionDescriptor, parent: DRIWithPlatformInfo): Function {
+        val expected = descriptor.takeIf { it.isExpect }?.resolveDescriptorData()
+        val actual = listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
+        val dri = parent.dri.copy(callable = Callable.from(descriptor))
+
+        return Function(
+            dri = dri,
+            name = descriptor.name.asString(),
+            returnType = descriptor.returnType?.let { KotlinTypeWrapper(it) },
+            isConstructor = false,
+            receiver = descriptor.extensionReceiverParameter?.let {
+                visitReceiverParameterDescriptor(
+                    it,
+                    DRIWithPlatformInfo(
+                        dri,
+                        expected?.filterTagWrappers(listOf(Receiver::class)),
+                        actual.filterTagWrappers(listOf(Receiver::class))
+                    )
+                )
+            },
+            parameters = descriptor.valueParameters.mapIndexed { index, desc ->
+                parameter(
+                    index, desc,
+                    DRIWithPlatformInfo(
+                        dri,
+                        expected.filterTagWrappers(listOf(Param::class), desc.name.asString()),
+                        actual.filterTagWrappers(listOf(Param::class), desc.name.asString())
+                    )
+                )
+            },
+            expected = expected,
+            actual = actual,
+            visibility = mapOf(platformData to descriptor.visibility)
+        )
+    }
+
+    override fun visitConstructorDescriptor(descriptor: ConstructorDescriptor, parent: DRIWithPlatformInfo): Function {
+        val dri = parent.dri.copy(callable = Callable.from(descriptor))
+        return Function(
+            dri = dri,
+            name = "<init>",
+            returnType = KotlinTypeWrapper(descriptor.returnType),
+            isConstructor = true,
+            receiver = null,
+            parameters = descriptor.valueParameters.mapIndexed { index, desc ->
+                parameter(
+                    index, desc,
+                    DRIWithPlatformInfo(
+                        dri,
+                        parent.expected.filterTagWrappers(listOf(Param::class)),
+                        parent.actual.filterTagWrappers(listOf(Param::class))
+                    )
+                )
+            },
+            expected = parent.expected ?: descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
+            actual = parent.actual,
+            visibility = mapOf(platformData to descriptor.visibility)
+        )
+    }
+
+    override fun visitReceiverParameterDescriptor(
+        descriptor: ReceiverParameterDescriptor,
+        parent: DRIWithPlatformInfo
+    ) = Parameter(
+        dri = parent.dri.copy(target = 0),
+        name = null,
+        type = KotlinTypeWrapper(descriptor.type),
+        expected = parent.expected,
+        actual = parent.actual
+    )
+
+    open fun visitPropertyAccessorDescriptor(
+        descriptor: PropertyAccessorDescriptor,
+        propertyDescriptor: PropertyDescriptor,
+        parent: DRI
+    ): Function {
+        val dri = parent.copy(callable = Callable.from(descriptor))
+        val isGetter = descriptor is PropertyGetterDescriptor
+
+        fun PropertyDescriptor.asParameter(parent: DRI) =
+            Parameter(
+                parent.copy(target = 1),
+                this.name.asString(),
+                KotlinTypeWrapper(this.type),
+                descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
+                listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData())
+            )
+
+        val name = run {
+            val modifier = if (isGetter) "get" else "set"
+            val rawName = propertyDescriptor.name.asString()
+            "$modifier${rawName[0].toUpperCase()}${rawName.drop(1)}"
+        }
+
+        descriptor.visibility
+        val parameters =
+            if (isGetter) {
+                emptyList()
+            } else {
+                listOf(propertyDescriptor.asParameter(dri))
+            }
+
+        return Function(
+            dri,
+            name,
+            descriptor.returnType?.let { KotlinTypeWrapper(it) },
+            false,
+            null,
+            parameters,
+            descriptor.takeIf { it.isExpect }?.resolveDescriptorData(),
+            listOfNotNull(descriptor.takeUnless { it.isExpect }?.resolveDescriptorData()),
+            visibility = mapOf(platformData to descriptor.visibility)
+        )
+    }
+
+    private fun parameter(index: Int, descriptor: ValueParameterDescriptor, parent: DRIWithPlatformInfo) =
+        Parameter(
+            dri = parent.dri.copy(target = index + 1),
+            name = descriptor.name.asString(),
+            type = KotlinTypeWrapper(descriptor.type),
+            expected = parent.expected,
+            actual = parent.actual
+        )
+
+    private fun MemberScope.functions(parent: DRIWithPlatformInfo): List<Function> =
+        getContributedDescriptors(DescriptorKindFilter.FUNCTIONS) { true }
+            .filterIsInstance<FunctionDescriptor>()
+            .map { visitFunctionDescriptor(it, parent) }
+
+    private fun MemberScope.properties(parent: DRIWithPlatformInfo): List<Property> =
+        getContributedDescriptors(DescriptorKindFilter.VALUES) { true }
+            .filterIsInstance<PropertyDescriptor>()
+            .map { visitPropertyDescriptor(it, parent) }
+
+    private fun MemberScope.classlikes(parent: DRIWithPlatformInfo): List<Classlike> =
+        getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) { true }
+            .filterIsInstance<ClassDescriptor>()
+            .map { visitClassDescriptor(it, parent) }
+
+    private fun DeclarationDescriptor.resolveDescriptorData(): PlatformInfo {
+        val doc = findKDoc()
+        val parser = MarkdownParser(resolutionFacade, this)
+        val docHeader = parser.parseFromKDocTag(doc)
+
+        return BasePlatformInfo(docHeader, listOf(platformData))
+    }
+
+    private fun ClassDescriptor.resolveClassDescriptionData(): ClassPlatformInfo {
+        return ClassPlatformInfo(resolveDescriptorData(),
+            (getSuperInterfaces() + getAllSuperclassesWithoutAny()).map { DRI.from(it) })
+    }
+
+    private fun PlatformInfo?.filterTagWrappers(
+        types: List<KClass<out TagWrapper>>,
+        name: String? = null
+    ): PlatformInfo? {
+        if (this == null)
+            return null
+        return BasePlatformInfo(
+            DocumentationNode(
+                this.documentationNode.children.filter { it::class in types && (it as? NamedTagWrapper)?.name == name }
+            ),
+            this.platformData
+        )
+    }
+
+    private fun List<PlatformInfo>.filterTagWrappers(
+        types: List<KClass<out TagWrapper>>,
+        name: String? = null
+    ): List<PlatformInfo> =
+        this.map { it.filterTagWrappers(types, name)!! }
+}
+
diff --git a/plugins/kotlin-as-java/build.gradle.kts b/plugins/kotlin-as-java/build.gradle.kts
index 3b281d53..32f9c931 100644
--- a/plugins/kotlin-as-java/build.gradle.kts
+++ b/plugins/kotlin-as-java/build.gradle.kts
@@ -5,4 +5,8 @@ publishing {
             from(components["java"])
         }
     }
+}
+
+dependencies {
+    implementation(project(":plugins:base"))
 }
\ No newline at end of file
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaDescriptorToDocumentationTranslator.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaDescriptorToDocumentationTranslator.kt
index 9c4ee9aa..1edf4aa1 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaDescriptorToDocumentationTranslator.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaDescriptorToDocumentationTranslator.kt
@@ -1,6 +1,9 @@
 package  org.jetbrains.dokka.kotlinAsJava
 
 import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+import org.jetbrains.dokka.base.transformers.descriptors.DRIWithPlatformInfo
+import org.jetbrains.dokka.base.transformers.descriptors.DokkaDescriptorVisitor
+import org.jetbrains.dokka.base.transformers.descriptors.withEmptyInfo
 import org.jetbrains.dokka.links.Callable
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.withClass
@@ -8,18 +11,16 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.transformers.descriptors.DRIWithPlatformInfo
 import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTranslator
-import org.jetbrains.dokka.transformers.descriptors.DokkaDescriptorVisitor
-import org.jetbrains.dokka.transformers.descriptors.withEmptyInfo
 import org.jetbrains.kotlin.descriptors.*
 
-object KotlinAsJavaDescriptorToDocumentationTranslator : DescriptorToDocumentationTranslator {
+class KotlinAsJavaDescriptorToDocumentationTranslator(
+    private val context: DokkaContext
+) : DescriptorToDocumentationTranslator {
     override fun invoke(
         moduleName: String,
         packageFragments: Iterable<PackageFragmentDescriptor>,
-        platformData: PlatformData,
-        context: DokkaContext
+        platformData: PlatformData
     ): Module =
         KotlinAsJavaDokkaDescriptorVisitor(platformData, context.platforms[platformData]?.facade!!).run {
             packageFragments.map { visitPackageFragmentDescriptor(it, DRI.topLevel.withEmptyInfo()) }
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageBuilder.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageBuilder.kt
index 8f026477..6fe10ce1 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageBuilder.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageBuilder.kt
@@ -9,7 +9,6 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Enum
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.transformers.descriptors.KotlinClassKindTypes
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
index 05896d11..a5d0bd33 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
@@ -2,8 +2,8 @@ package org.jetbrains.dokka.kotlinAsJava
 
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.model.JavaTypeWrapper
 import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.transformers.psi.JavaTypeWrapper
 import org.jetbrains.dokka.utilities.DokkaLogger
 
 class KotlinAsJavaPageContentBuilder(
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
index 345dc9be..e99e0843 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
@@ -12,8 +12,12 @@ import org.jetbrains.dokka.transformers.documentation.DocumentationToPageTransla
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 
 class KotlinAsJavaPlugin : DokkaPlugin() {
-    val kotlinAsJavaDescriptorToDocumentableTranslator by extending { CoreExtensions.descriptorToDocumentationTranslator with KotlinAsJavaDescriptorToDocumentationTranslator }
-    val kotlinAsJavaDocumentableToPageTranslator by extending { CoreExtensions.documentationToPageTranslator with KotlinAsJavaDocumentationToPageTranslator }
+    val kotlinAsJavaDescriptorToDocumentableTranslator by extending {
+        CoreExtensions.descriptorToDocumentationTranslator providing ::KotlinAsJavaDescriptorToDocumentationTranslator
+    }
+    val kotlinAsJavaDocumentableToPageTranslator by extending {
+        CoreExtensions.documentationToPageTranslator with KotlinAsJavaDocumentationToPageTranslator
+    }
 }
 
 object DescriptorCache {
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinToJVMResolver.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinToJVMResolver.kt
index 87a173f3..7b0495e9 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinToJVMResolver.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinToJVMResolver.kt
@@ -5,7 +5,6 @@ import org.jetbrains.dokka.links.*
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.model.Enum
-import org.jetbrains.dokka.transformers.psi.JavaTypeWrapper
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-- 
cgit 


From e82beddda7b51f285f0422c6a7078a0a80d54d14 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Thu, 13 Feb 2020 16:05:04 +0100
Subject: Adds option to mark extension as fallback

---
 core/src/main/kotlin/DokkaGenerator.kt             |  1 -
 core/src/main/kotlin/plugability/DokkaContext.kt   | 32 +++++++++++++---------
 core/src/main/kotlin/plugability/DokkaPlugin.kt    | 11 ++++++--
 core/src/main/kotlin/plugability/extensions.kt     | 28 ++++++++++++++-----
 core/src/main/kotlin/renderers/DefaultRenderer.kt  |  1 -
 core/src/main/kotlin/renderers/OutputWriter.kt     |  4 ---
 .../kotlin/resolvers/DefaultLocationProvider.kt    |  2 --
 .../DefaultDocumentationToPageTranslator.kt        |  1 -
 plugins/base/src/main/kotlin/DokkaBase.kt          |  2 +-
 .../src/main/kotlin/KotlinAsJavaPlugin.kt          |  1 -
 10 files changed, 49 insertions(+), 34 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 6a21e031..573ba13e 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -10,7 +10,6 @@ import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 6a8ac4a3..b4be5862 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -17,6 +17,8 @@ interface DokkaContext {
     operator fun <T, E> get(point: E, askDefault: AskDefault = AskDefault.WhenEmpty): List<T>
             where T : Any, E : ExtensionPoint<T>
 
+    fun <T, E> single(point: E): T where T : Any, E : ExtensionPoint<T>
+
     val logger: DokkaLogger
     val configuration: DokkaConfiguration
     val platforms: Map<PlatformData, EnvironmentAndFacade>
@@ -41,19 +43,6 @@ interface DokkaContext {
     }
 }
 
-fun <T, E> DokkaContext.single(point: E): T where T : Any, E : ExtensionPoint<T> {
-    fun throwBadArity(substitution: String): Nothing = throw IllegalStateException(
-        "$point was expected to have exactly one extension registered, but $substitution found."
-    )
-
-    val extensions = get(point, AskDefault.WhenEmpty)
-    return when (extensions.size) {
-        0 -> throwBadArity("none was")
-        1 -> extensions.first()
-        else -> throwBadArity("multiple were")
-    }
-}
-
 interface DokkaContextConfiguration {
     fun addExtensionDependencies(extension: Extension<*>)
 }
@@ -110,6 +99,23 @@ private class DokkaContextConfigurationImpl(
                 actions(point)?.takeIf { it.isNotEmpty() } ?: DefaultExtensions.get(point, this)
         } as List<T>
 
+    @Suppress("UNCHECKED_CAST")
+    override fun <T, E> single(point: E): T where T : Any, E : ExtensionPoint<T> {
+        fun throwBadArity(substitution: String): Nothing = throw IllegalStateException(
+            "$point was expected to have exactly one extension registered, but $substitution found."
+        )
+
+        val extensions = extensions[point].orEmpty() as List<Extension<T>>
+        return when (extensions.size) {
+            0 -> DefaultExtensions.get(point, this).single() ?: throwBadArity("none was")
+            1 -> extensions.single().action.get(this)
+            else -> {
+                val notFallbacks = extensions.filterNot { it.isFallback }
+                if (notFallbacks.size == 1)  notFallbacks.single().action.get(this) else throwBadArity("many were")
+            }
+        }
+    }
+
     private fun <E : ExtensionPoint<*>> actions(point: E) = extensions[point]?.map { it.action.get(this) }
 
     @Suppress("UNCHECKED_CAST")
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 1fcbd934..cdc92ca5 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -14,7 +14,7 @@ abstract class DokkaPlugin {
     internal var context: DokkaContext? = null
 
     protected inline fun <reified T : DokkaPlugin> plugin(): T = context?.plugin(T::class)
-            ?: throw IllegalStateException("Querying about plugins is only possible with dokka context initialised")
+        ?: throw IllegalStateException("Querying about plugins is only possible with dokka context initialised")
 
     protected fun <T : Any> extensionPoint() =
         object : ReadOnlyProperty<DokkaPlugin, ExtensionPoint<T>> {
@@ -24,7 +24,12 @@ abstract class DokkaPlugin {
             )
         }
 
-    protected fun <T : Any> extending(definition: ExtendingDSL.() -> Extension<T>) = ExtensionProvider(definition)
+    protected fun <T : Any> extending(isFallback: Boolean = false, definition: ExtendingDSL.() -> Extension<T>) =
+        if (isFallback) {
+            ExtensionProvider { definition().markedAsFallback() }
+        } else {
+            ExtensionProvider(definition)
+        }
 
     protected class ExtensionProvider<T : Any> internal constructor(
         private val definition: ExtendingDSL.() -> Extension<T>
@@ -41,6 +46,6 @@ abstract class DokkaPlugin {
         extensionDelegates.asSequence()
             .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // should be always true
             .map { it.get(this) }
-            .forEach { if(it.condition.invoke(configuration)) ctx.addExtensionDependencies(it) }
+            .forEach { if (it.condition.invoke(configuration)) ctx.addExtensionDependencies(it) }
     }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index 4cbb61eb..46c356df 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -15,7 +15,8 @@ abstract class Extension<T : Any> internal constructor(
     internal val extensionName: String,
     internal val action: LazyEvaluated<T>,
     internal val ordering: (OrderDsl.() -> Unit)? = null,
-    internal val condition: DokkaConfiguration.() -> Boolean = { true }
+    internal val condition: DokkaConfiguration.() -> Boolean = { true },
+    internal val isFallback: Boolean
 ) {
     override fun toString() = "Extension: $pluginClass/$extensionName"
 
@@ -26,6 +27,8 @@ abstract class Extension<T : Any> internal constructor(
     override fun hashCode() = listOf(pluginClass, extensionName).hashCode()
 
     abstract fun setCondition(condition: (DokkaConfiguration.() -> Boolean)): Extension<T>
+
+    abstract fun markedAsFallback(): Extension<T>
 }
 
 class ExtensionOrdered<T : Any> internal constructor(
@@ -34,17 +37,22 @@ class ExtensionOrdered<T : Any> internal constructor(
     extensionName: String,
     action: LazyEvaluated<T>,
     ordering: (OrderDsl.() -> Unit),
-    condition: DokkaConfiguration.() -> Boolean = { true }
+    condition: DokkaConfiguration.() -> Boolean = { true },
+    isFallback: Boolean = false
 ) : Extension<T>(
     extensionPoint,
     pluginClass,
     extensionName,
     action,
     ordering,
-    condition
+    condition,
+    isFallback
 ) {
     override fun setCondition(condition: DokkaConfiguration.() -> Boolean) =
         ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, condition)
+
+    override fun markedAsFallback() =
+        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, condition, true)
 }
 
 class ExtensionUnordered<T : Any> internal constructor(
@@ -52,17 +60,22 @@ class ExtensionUnordered<T : Any> internal constructor(
     pluginClass: String,
     extensionName: String,
     action: LazyEvaluated<T>,
-    condition: DokkaConfiguration.() -> Boolean = { true }
+    condition: DokkaConfiguration.() -> Boolean = { true },
+    isFallback: Boolean = false
 ) : Extension<T>(
     extensionPoint,
     pluginClass,
     extensionName,
     action,
     null,
-    condition
+    condition,
+    isFallback
 ) {
     override fun setCondition(condition: DokkaConfiguration.() -> Boolean) =
         ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, condition)
+
+    override fun markedAsFallback() =
+        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, condition, true)
 }
 
 internal data class Ordering(val previous: Set<Extension<*>>, val following: Set<Extension<*>>)
@@ -79,10 +92,11 @@ class ExtendingDSL(private val pluginClass: String, private val extensionName: S
     infix fun <T : Any> ExtensionPoint<T>.providing(action: (DokkaContext) -> T) =
         ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromRecipe(action))
 
-    infix fun <T: Any> ExtensionUnordered<T>.order(block: OrderDsl.() -> Unit) =
+    infix fun <T : Any> ExtensionUnordered<T>.order(block: OrderDsl.() -> Unit) =
         ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, block)
 
-    infix fun <T : Any> Extension<T>.applyIf(condition: DokkaConfiguration.() -> Boolean): Extension<T> = this.setCondition(condition)
+    infix fun <T : Any> Extension<T>.applyIf(condition: DokkaConfiguration.() -> Boolean): Extension<T> =
+        this.setCondition(condition)
 }
 
 @ExtensionsDsl
diff --git a/core/src/main/kotlin/renderers/DefaultRenderer.kt b/core/src/main/kotlin/renderers/DefaultRenderer.kt
index 16cdb4c1..d09d9ded 100644
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/core/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -3,7 +3,6 @@ package org.jetbrains.dokka.renderers
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.resolvers.LocationProvider
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
diff --git a/core/src/main/kotlin/renderers/OutputWriter.kt b/core/src/main/kotlin/renderers/OutputWriter.kt
index 30b2b0b6..e317f8ef 100644
--- a/core/src/main/kotlin/renderers/OutputWriter.kt
+++ b/core/src/main/kotlin/renderers/OutputWriter.kt
@@ -1,9 +1,5 @@
 package org.jetbrains.dokka.renderers
 
-import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.single
-
 interface OutputWriter {
 
     fun write(path: String, text: String, ext: String)
diff --git a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
index d30264bb..65d2f794 100644
--- a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
+++ b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
@@ -1,10 +1,8 @@
 package org.jetbrains.dokka.resolvers
 
-import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.utilities.htmlEscape
 import java.util.*
 
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
index 81c6dfea..c2a21150 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
@@ -6,7 +6,6 @@ import org.jetbrains.dokka.pages.DefaultPageBuilder
 import org.jetbrains.dokka.pages.DefaultPageContentBuilder
 import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.single
 
 
 object DefaultDocumentationToPageTranslator : DocumentationToPageTranslator {
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index 5c579e54..648acfbb 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -5,7 +5,7 @@ import org.jetbrains.dokka.base.transformers.descriptors.DefaultDescriptorToDocu
 import org.jetbrains.dokka.plugability.DokkaPlugin
 
 class DokkaBase: DokkaPlugin() {
-    val defaultDescriptorToDocumentationTranslator by extending {
+    val defaultDescriptorToDocumentationTranslator by extending(isFallback = true) {
         CoreExtensions.descriptorToDocumentationTranslator providing ::DefaultDescriptorToDocumentationTranslator
     }
 }
\ No newline at end of file
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
index e99e0843..dd95f00e 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
@@ -7,7 +7,6 @@ import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.transformers.documentation.DocumentationToPageTranslator
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 
-- 
cgit 


From 705c6d45f95408633c71bc0bcd6bc93c9d79a381 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Sun, 16 Feb 2020 23:02:30 +0100
Subject: Renames DocumentationMerger and moves it to base plugin

---
 core/src/main/kotlin/CoreExtensions.kt             |   4 +-
 core/src/main/kotlin/DokkaGenerator.kt             |   2 +-
 .../main/kotlin/plugability/DefaultExtensions.kt   |   2 -
 .../DefaultDocumentationNodeMerger.kt              | 114 --------------------
 .../documentation/DocumentableMerger.kt            |   8 ++
 .../documentation/DocumentationNodeMerger.kt       |   8 --
 core/src/main/kotlin/utilities/genericUtils.kt     |   3 +
 plugins/base/src/main/kotlin/DokkaBase.kt          |   5 +
 .../documentables/DefaultDocumentableMerger.kt     | 116 +++++++++++++++++++++
 9 files changed, 135 insertions(+), 127 deletions(-)
 delete mode 100644 core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
 create mode 100644 core/src/main/kotlin/transformers/documentation/DocumentableMerger.kt
 delete mode 100644 core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
 create mode 100644 core/src/main/kotlin/utilities/genericUtils.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 1364f1c1..47f2e4c1 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -6,7 +6,7 @@ import org.jetbrains.dokka.renderers.Renderer
 import org.jetbrains.dokka.renderers.OutputWriter
 import org.jetbrains.dokka.resolvers.LocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTranslator
-import org.jetbrains.dokka.transformers.documentation.DocumentationNodeMerger
+import org.jetbrains.dokka.transformers.documentation.DocumentableMerger
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeTransformer
 import org.jetbrains.dokka.transformers.documentation.DocumentationToPageTranslator
 import org.jetbrains.dokka.transformers.pages.PageMergerStrategy
@@ -22,7 +22,7 @@ import kotlin.reflect.KProperty
 object CoreExtensions {
     val descriptorToDocumentationTranslator by coreExtension<DescriptorToDocumentationTranslator>()
     val psiToDocumentationTranslator by coreExtension<PsiToDocumentationTranslator>()
-    val documentationMerger by coreExtension<DocumentationNodeMerger>()
+    val documentableMerger by coreExtension<DocumentableMerger>()
     val documentationTransformer by coreExtension<DocumentationNodeTransformer>()
     val commentsToContentConverter by coreExtension<CommentsToContentConverter>()
     val documentationToPageTranslator by coreExtension<DocumentationToPageTranslator>()
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 573ba13e..1829c9e4 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -78,7 +78,7 @@ class DokkaGenerator(
     fun mergeDocumentationModels(
         modulesFromPlatforms: List<Module>,
         context: DokkaContext
-    ) = context.single(CoreExtensions.documentationMerger).invoke(modulesFromPlatforms, context)
+    ) = context.single(CoreExtensions.documentableMerger).invoke(modulesFromPlatforms, context)
 
     fun transformDocumentationModel(
         documentationModel: Module,
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 70a7e4db..c1a72c74 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -6,7 +6,6 @@ import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.OutputWriter
 import org.jetbrains.dokka.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
-import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationNodeMerger
 import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
 import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
@@ -28,7 +27,6 @@ internal object DefaultExtensions {
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
             CoreExtensions.psiToDocumentationTranslator -> DefaultPsiToDocumentationTranslator
-            CoreExtensions.documentationMerger -> DefaultDocumentationNodeMerger
             CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
             CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
             CoreExtensions.pageTransformer -> DefaultPageNodeMerger(fullContext)
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
deleted file mode 100644
index 0d7fa249..00000000
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
+++ /dev/null
@@ -1,114 +0,0 @@
-package org.jetbrains.dokka.transformers.documentation
-
-import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.model.Enum
-import org.jetbrains.dokka.model.Function
-import org.jetbrains.dokka.plugability.DokkaContext
-
-internal object DefaultDocumentationNodeMerger : DocumentationNodeMerger {
-    override fun invoke(modules: Collection<Module>, context: DokkaContext): Module {
-        if (!modules.all { it.name == modules.first().name })
-            context.logger.error("All module names need to be the same")
-        return Module(
-            modules.first().name,
-            merge(
-                modules.flatMap { it.packages },
-                Package::mergeWith
-            )
-        )
-    }
-}
-
-private fun <T : Documentable> merge(elements: List<T>, reducer: (T, T) -> T): List<T> =
-    elements.groupingBy { it.dri }
-        .reduce { _, left, right -> reducer(left, right) }
-        .values.toList()
-
-fun PlatformInfo.mergeWith(other: PlatformInfo?) = BasePlatformInfo(
-    documentationNode,
-    (platformData + (other?.platformData ?: emptyList())).distinct()
-)
-
-fun ClassPlatformInfo.mergeWith(other: ClassPlatformInfo?) = ClassPlatformInfo(
-    info.mergeWith(other?.info),
-    (inherited + (other?.inherited ?: emptyList())).distinct()
-)
-
-fun List<ClassPlatformInfo>.mergeClassPlatformInfo(): List<ClassPlatformInfo> =
-    groupingBy { it.documentationNode.children + it.inherited }.reduce { _, left, right ->
-        left.mergeWith(right)
-    }.values.toList()
-
-fun List<PlatformInfo>.merge(): List<PlatformInfo> =
-    groupingBy { it.documentationNode }.reduce { _, left, right ->
-        left.mergeWith(right)
-    }.values.toList()
-
-fun Function.mergeWith(other: Function): Function = Function(
-    dri,
-    name,
-    returnType,
-    isConstructor,
-    if (receiver != null && other.receiver != null) receiver.mergeWith(other.receiver) else null,
-    merge(parameters + other.parameters, Parameter::mergeWith),
-    expected?.mergeWith(other.expected),
-    (actual + other.actual).merge(),
-    visibility = (visibility + other.visibility)
-)
-
-fun Property.mergeWith(other: Property) = Property(
-    dri,
-    name,
-    if (receiver != null && other.receiver != null) receiver.mergeWith(other.receiver) else null,
-    expected?.mergeWith(other.expected),
-    (actual + other.actual).merge(),
-    accessors = (this.accessors + other.accessors).distinct(),
-    visibility = (visibility + other.visibility)
-)
-
-fun Classlike.mergeWith(other: Classlike): Classlike = when {
-    this is Class && other is Class -> mergeWith(other)
-    this is Enum && other is Enum -> mergeWith(other)
-    else -> throw IllegalStateException("${this::class.qualifiedName} ${this.name} cannot be merged with ${other::class.qualifiedName} ${other.name}")
-}
-
-fun Class.mergeWith(other: Class) = Class(
-    dri = dri,
-    name = name,
-    kind = kind,
-    constructors = merge(constructors + other.constructors, Function::mergeWith),
-    functions = merge(functions + other.functions, Function::mergeWith),
-    properties = merge(properties + other.properties, Property::mergeWith),
-    classlikes = merge(classlikes + other.classlikes, Classlike::mergeWith),
-    expected = expected?.mergeWith(other.expected),
-    actual = (actual + other.actual).mergeClassPlatformInfo(),
-    visibility = (visibility + other.visibility)
-)
-
-fun Enum.mergeWith(other: Enum) = Enum(
-    dri = dri,
-    name = name,
-    functions = merge(functions + other.functions, Function::mergeWith),
-    properties = merge(properties + other.properties, Property::mergeWith),
-    classlikes = merge(classlikes + other.classlikes, Classlike::mergeWith),
-    expected = expected?.mergeWith(other.expected),
-    actual = (actual + other.actual).mergeClassPlatformInfo(),
-    entries = (this.entries + other.entries.distinctBy { it.dri }.toList()),
-    constructors = merge(constructors + other.constructors, Function::mergeWith),
-    visibility = visibility
-)
-
-fun Parameter.mergeWith(other: Parameter) = Parameter(
-    dri,
-    name,
-    type,
-    expected?.mergeWith(other.expected),
-    (actual + other.actual).merge()
-)
-
-fun Package.mergeWith(other: Package): Package = Package(
-    dri,
-    merge(functions + other.functions, Function::mergeWith),
-    merge(properties + other.properties, Property::mergeWith),
-    merge(classlikes + other.classlikes, Classlike::mergeWith)
-)
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentableMerger.kt b/core/src/main/kotlin/transformers/documentation/DocumentableMerger.kt
new file mode 100644
index 00000000..5a17bc24
--- /dev/null
+++ b/core/src/main/kotlin/transformers/documentation/DocumentableMerger.kt
@@ -0,0 +1,8 @@
+package org.jetbrains.dokka.transformers.documentation
+
+import org.jetbrains.dokka.model.Module
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface DocumentableMerger {
+    operator fun invoke(modules: Collection<Module>, context: DokkaContext): Module
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
deleted file mode 100644
index 25be625e..00000000
--- a/core/src/main/kotlin/transformers/documentation/DocumentationNodeMerger.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package org.jetbrains.dokka.transformers.documentation
-
-import org.jetbrains.dokka.model.Module
-import org.jetbrains.dokka.plugability.DokkaContext
-
-interface DocumentationNodeMerger {
-    operator fun invoke(modules: Collection<Module>, context: DokkaContext): Module
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/utilities/genericUtils.kt b/core/src/main/kotlin/utilities/genericUtils.kt
new file mode 100644
index 00000000..e94e4e8f
--- /dev/null
+++ b/core/src/main/kotlin/utilities/genericUtils.kt
@@ -0,0 +1,3 @@
+package org.jetbrains.dokka.utilities
+
+fun <T : Any, S : Any> Pair<T?, S?>.pullOutNull(): Pair<T, S>? = first?.let { f -> second?.let { s -> f to s } }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index 648acfbb..b18e2ad5 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -2,10 +2,15 @@ package org.jetbrains.dokka.base
 
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.base.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
+import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentableMerger
 import org.jetbrains.dokka.plugability.DokkaPlugin
 
 class DokkaBase: DokkaPlugin() {
     val defaultDescriptorToDocumentationTranslator by extending(isFallback = true) {
         CoreExtensions.descriptorToDocumentationTranslator providing ::DefaultDescriptorToDocumentationTranslator
     }
+
+    val defaultDocumentableMerger by extending(isFallback = true) {
+        CoreExtensions.documentableMerger with DefaultDocumentableMerger
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
new file mode 100644
index 00000000..f2e6f177
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
@@ -0,0 +1,116 @@
+package org.jetbrains.dokka.base.transformers.documentables
+
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Enum
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.transformers.documentation.DocumentableMerger
+import org.jetbrains.dokka.utilities.pullOutNull
+
+internal object DefaultDocumentableMerger : DocumentableMerger {
+    override fun invoke(modules: Collection<Module>, context: DokkaContext): Module {
+        if (!modules.all { it.name == modules.first().name })
+            context.logger.error("All module names need to be the same")
+        return Module(
+            modules.first().name,
+            merge(
+                modules.flatMap { it.packages },
+                Package::mergeWith
+            )
+        )
+    }
+}
+
+private fun <T : Documentable> merge(elements: List<T>, reducer: (T, T) -> T): List<T> =
+    elements.groupingBy { it.dri }
+        .reduce { _, left, right -> reducer(left, right) }
+        .values.toList()
+
+fun PlatformInfo.mergeWith(other: PlatformInfo?) = BasePlatformInfo(
+    documentationNode,
+    (platformData + (other?.platformData ?: emptyList())).distinct()
+)
+
+fun ClassPlatformInfo.mergeWith(other: ClassPlatformInfo?) = ClassPlatformInfo(
+    info.mergeWith(other?.info),
+    (inherited + (other?.inherited ?: emptyList())).distinct()
+)
+
+fun List<ClassPlatformInfo>.mergeClassPlatformInfo(): List<ClassPlatformInfo> =
+    groupingBy { it.documentationNode.children + it.inherited }.reduce { _, left, right ->
+        left.mergeWith(right)
+    }.values.toList()
+
+fun List<PlatformInfo>.merge(): List<PlatformInfo> =
+    groupingBy { it.documentationNode }.reduce { _, left, right ->
+        left.mergeWith(right)
+    }.values.toList()
+
+fun Function.mergeWith(other: Function): Function = Function(
+    dri,
+    name,
+    returnType,
+    isConstructor,
+    (receiver to other.receiver).pullOutNull()?.let { (f, s) -> f.mergeWith(s) },
+    merge(parameters + other.parameters, Parameter::mergeWith),
+    expected?.mergeWith(other.expected),
+    (actual + other.actual).merge(),
+    visibility = (visibility + other.visibility)
+)
+
+fun Property.mergeWith(other: Property) = Property(
+    dri,
+    name,
+    (receiver to other.receiver).pullOutNull()?.let { (f, s) -> f.mergeWith(s) },
+    expected?.mergeWith(other.expected),
+    (actual + other.actual).merge(),
+    accessors = (this.accessors + other.accessors).distinct(),
+    visibility = (visibility + other.visibility)
+)
+
+fun Classlike.mergeWith(other: Classlike): Classlike = when {
+    this is Class && other is Class -> mergeWith(other)
+    this is Enum && other is Enum -> mergeWith(other)
+    else -> throw IllegalStateException("${this::class.qualifiedName} ${this.name} cannot be merged with ${other::class.qualifiedName} ${other.name}")
+}
+
+fun Class.mergeWith(other: Class) = Class(
+    dri = dri,
+    name = name,
+    kind = kind,
+    constructors = merge(constructors + other.constructors, Function::mergeWith),
+    functions = merge(functions + other.functions, Function::mergeWith),
+    properties = merge(properties + other.properties, Property::mergeWith),
+    classlikes = merge(classlikes + other.classlikes, Classlike::mergeWith),
+    expected = expected?.mergeWith(other.expected),
+    actual = (actual + other.actual).mergeClassPlatformInfo(),
+    visibility = (visibility + other.visibility)
+)
+
+fun Enum.mergeWith(other: Enum) = Enum(
+    dri = dri,
+    name = name,
+    functions = merge(functions + other.functions, Function::mergeWith),
+    properties = merge(properties + other.properties, Property::mergeWith),
+    classlikes = merge(classlikes + other.classlikes, Classlike::mergeWith),
+    expected = expected?.mergeWith(other.expected),
+    actual = (actual + other.actual).mergeClassPlatformInfo(),
+    entries = (this.entries + other.entries.distinctBy { it.dri }.toList()),
+    constructors = merge(constructors + other.constructors, Function::mergeWith),
+    visibility = visibility
+)
+
+fun Parameter.mergeWith(other: Parameter) = Parameter(
+    dri,
+    name,
+    type,
+    expected?.mergeWith(other.expected),
+    (actual + other.actual).merge()
+)
+
+fun Package.mergeWith(other: Package): Package = Package(
+    dri,
+    merge(functions + other.functions, Function::mergeWith),
+    merge(properties + other.properties, Property::mergeWith),
+    merge(classlikes + other.classlikes, Classlike::mergeWith)
+)
\ No newline at end of file
-- 
cgit 


From 3b200cf10e0c50c2eee4b9da3f7039d678fa4aad Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Sun, 16 Feb 2020 23:20:17 +0100
Subject: Renames DocumentationToPagesTranslatero and moves its implementation
 to base plugin

---
 core/src/main/kotlin/CoreExtensions.kt             |   4 +-
 core/src/main/kotlin/DokkaGenerator.kt             |   2 +-
 core/src/main/kotlin/pages/PageBuilder.kt          | 158 ---------------
 core/src/main/kotlin/pages/PageContentBuilder.kt   | 215 --------------------
 .../main/kotlin/plugability/DefaultExtensions.kt   |   2 -
 .../DefaultDocumentationToPageTranslator.kt        |  23 ---
 .../documentation/DocumentablesToPageTranslator.kt |   9 +
 .../documentation/DocumentationToPageTranslator.kt |   9 -
 plugins/base/src/main/kotlin/DokkaBase.kt          |   9 +-
 .../DefaultDocumentablesToPageTranslator.kt        |  22 +++
 .../transformers/documentables/PageBuilder.kt      | 159 +++++++++++++++
 .../documentables/PageContentBuilder.kt            | 217 +++++++++++++++++++++
 .../src/main/kotlin/KotlinAsJavaPageBuilder.kt     |   2 +
 .../main/kotlin/KotlinAsJavaPageContentBuilder.kt  |  17 +-
 .../src/main/kotlin/KotlinAsJavaPlugin.kt          |   6 +-
 15 files changed, 432 insertions(+), 422 deletions(-)
 delete mode 100644 core/src/main/kotlin/pages/PageBuilder.kt
 delete mode 100644 core/src/main/kotlin/pages/PageContentBuilder.kt
 delete mode 100644 core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
 create mode 100644 core/src/main/kotlin/transformers/documentation/DocumentablesToPageTranslator.kt
 delete mode 100644 core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/documentables/PageBuilder.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 47f2e4c1..8ae333ee 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -8,7 +8,7 @@ import org.jetbrains.dokka.resolvers.LocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTranslator
 import org.jetbrains.dokka.transformers.documentation.DocumentableMerger
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeTransformer
-import org.jetbrains.dokka.transformers.documentation.DocumentationToPageTranslator
+import org.jetbrains.dokka.transformers.documentation.DocumentablesToPageTranslator
 import org.jetbrains.dokka.transformers.pages.PageMergerStrategy
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 import org.jetbrains.dokka.transformers.psi.PsiToDocumentationTranslator
@@ -25,7 +25,7 @@ object CoreExtensions {
     val documentableMerger by coreExtension<DocumentableMerger>()
     val documentationTransformer by coreExtension<DocumentationNodeTransformer>()
     val commentsToContentConverter by coreExtension<CommentsToContentConverter>()
-    val documentationToPageTranslator by coreExtension<DocumentationToPageTranslator>()
+    val documentablesToPageTranslator by coreExtension<DocumentablesToPageTranslator>()
     val pageTransformer by coreExtension<PageNodeTransformer>()
     val locationProviderFactory by coreExtension<LocationProviderFactory>()
     val outputWriter by coreExtension<OutputWriter>()
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 1829c9e4..1ad93f4f 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -88,7 +88,7 @@ class DokkaGenerator(
     fun createPages(
         transformedDocumentation: Module,
         context: DokkaContext
-    ) = context.single(CoreExtensions.documentationToPageTranslator).invoke(transformedDocumentation, context)
+    ) = context.single(CoreExtensions.documentablesToPageTranslator).invoke(transformedDocumentation, context)
 
     fun transformPages(
         pages: RootPageNode,
diff --git a/core/src/main/kotlin/pages/PageBuilder.kt b/core/src/main/kotlin/pages/PageBuilder.kt
deleted file mode 100644
index eb6f5e21..00000000
--- a/core/src/main/kotlin/pages/PageBuilder.kt
+++ /dev/null
@@ -1,158 +0,0 @@
-package org.jetbrains.dokka.pages
-
-import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.model.Enum
-import org.jetbrains.dokka.model.Function
-import org.jetbrains.dokka.model.doc.TagWrapper
-
-open class DefaultPageBuilder(
-    override val rootContentGroup: RootContentBuilder
-) : PageBuilder {
-
-    override fun pageForModule(m: Module): ModulePageNode =
-        ModulePageNode(m.name.ifEmpty { "root" }, contentForModule(m), m, m.packages.map { pageForPackage(it) })
-
-    override fun pageForPackage(p: Package) =
-        PackagePageNode(p.name, contentForPackage(p), setOf(p.dri), p,
-            p.classlikes.map { pageForClasslike(it) } +
-                    p.functions.map { pageForMember(it) })
-
-    override fun pageForClasslike(c: Classlike): ClasslikePageNode {
-        val constructors = when (c) {
-            is Class -> c.constructors
-            is Enum -> c.constructors
-            else -> emptyList()
-        }
-
-        return ClasslikePageNode(c.name, contentForClasslike(c), setOf(c.dri), c,
-            constructors.map { pageForMember(it) } +
-                    c.classlikes.map { pageForClasslike(it) } +
-                    c.functions.map { pageForMember(it) })
-    }
-
-    override fun pageForMember(m: CallableNode): MemberPageNode =
-        when (m) {
-            is Function ->
-                MemberPageNode(m.name, contentForFunction(m), setOf(m.dri), m)
-            else -> throw IllegalStateException("$m should not be present here")
-        }
-
-    protected open fun group(node: Documentable, content: PageContentBuilderFunction) =
-        rootContentGroup(node, ContentKind.Main, content)
-
-    protected open fun contentForModule(m: Module) = group(m) {
-        header(1) { text("root") }
-        block("Packages", 2, ContentKind.Packages, m.packages, m.platformData) {
-            link(it.name, it.dri)
-        }
-        text("Index\n")
-        text("Link to allpage here")
-    }
-
-    protected open fun contentForPackage(p: Package) = group(p) {
-        header(1) { text("Package ${p.name}") }
-        block("Types", 2, ContentKind.Properties, p.classlikes, p.platformData) {
-            link(it.name, it.dri)
-            text(it.briefDocTagString)
-        }
-        block("Functions", 2, ContentKind.Functions, p.functions, p.platformData) {
-            link(it.name, it.dri)
-            signature(it)
-            text(it.briefDocTagString)
-        }
-    }
-
-    open fun contentForClasslike(c: Classlike): ContentGroup = when (c) {
-        is Class -> contentForClass(c)
-        is Enum -> contentForEnum(c)
-        else -> throw IllegalStateException("$c should not be present here")
-    }
-
-    protected fun contentForClass(c: Class) = group(c) {
-        header(1) { text(c.name) }
-
-        c.inherited.takeIf { it.isNotEmpty() }?.let {
-            header(2) { text("SuperInterfaces") }
-            linkTable(it)
-        }
-        contentForComments(c)
-        block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) {
-            link(it.name, it.dri)
-            signature(it)
-            text(it.briefDocTagString)
-        }
-        block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) {
-            link(it.name, it.dri)
-            signature(it)
-            text(it.briefDocTagString)
-        }
-        block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) {
-            link(it.name, it.dri)
-            text(it.briefDocTagString)
-
-        }
-    }
-
-    fun contentForEnum(c: Enum): ContentGroup = group(c) {
-        header(1) { text("enum ${c.name}") }
-
-        block("Entries", 2, ContentKind.Properties, c.entries, c.platformData) { entry ->
-            link(entry.name, entry.dri)
-            contentForComments(entry)
-        }
-
-        c.inherited.takeIf { it.isNotEmpty() }?.let {
-            header(2) { text("SuperInterfaces") }
-            linkTable(it)
-        }
-        contentForComments(c)
-        block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) {
-            link(it.name, it.dri)
-            signature(it)
-            text(it.briefDocTagString)
-        }
-        block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) {
-            link(it.name, it.dri)
-            signature(it)
-            text(it.briefDocTagString)
-        }
-        block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) {
-            link(it.name, it.dri)
-            text(it.briefDocTagString)
-        }
-    }
-
-    private fun PageContentBuilder.contentForComments(d: Documentable) =
-        d.platformInfo.forEach { platformInfo ->
-            platformInfo.documentationNode.children.forEach {
-                header(3) {
-                    text(it.toHeaderString())
-                    text(" [${platformInfo.platformData.joinToString(", ") { it.platformType.name }}]")
-                }
-                comment(it.root)
-                text("\n")
-            }
-        }
-
-    private fun contentForFunction(f: Function) = group(f) {
-        header(1) { text(f.name) }
-        signature(f)
-        contentForComments(f)
-        block("Parameters", 2, ContentKind.Parameters, f.children, f.platformData) {
-            text(it.name ?: "<receiver>")
-            it.platformInfo.forEach { it.documentationNode.children.forEach { comment(it.root) } }
-        }
-    }
-
-    private fun TagWrapper.toHeaderString() = this.javaClass.toGenericString().split('.').last()
-}
-
-typealias RootContentBuilder = (Documentable, Kind, PageContentBuilderFunction) -> ContentGroup
-
-interface PageBuilder {
-    val rootContentGroup: RootContentBuilder
-    fun pageForModule(m: Module): ModulePageNode
-    fun pageForPackage(p: Package): PackagePageNode
-    fun pageForMember(m: CallableNode): MemberPageNode
-    fun pageForClasslike(c: Classlike): ClasslikePageNode
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/PageContentBuilder.kt b/core/src/main/kotlin/pages/PageContentBuilder.kt
deleted file mode 100644
index ed0a0fea..00000000
--- a/core/src/main/kotlin/pages/PageContentBuilder.kt
+++ /dev/null
@@ -1,215 +0,0 @@
-package org.jetbrains.dokka.pages
-
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.Documentable
-import org.jetbrains.dokka.model.Function
-import org.jetbrains.dokka.model.Parameter
-import org.jetbrains.dokka.model.TypeWrapper
-import org.jetbrains.dokka.model.doc.DocTag
-import org.jetbrains.dokka.utilities.DokkaLogger
-
-open class DefaultPageContentBuilder(
-    private val dri: Set<DRI>,
-    private val platformData: Set<PlatformData>,
-    private val kind: Kind,
-    private val commentsConverter: CommentsToContentConverter,
-    open val logger: DokkaLogger,
-    private val styles: Set<Style> = emptySet(),
-    private val extras: Set<Extra> = emptySet()
-) : PageContentBuilder {
-    protected val contents = mutableListOf<ContentNode>()
-
-    protected fun createText(text: String, kind: Kind = ContentKind.Symbol) =
-        ContentText(text, DCI(dri, kind), platformData, styles, extras)
-
-    protected fun build() = ContentGroup(
-        contents.toList(),
-        DCI(dri, kind),
-        platformData,
-        styles,
-        extras
-    )
-
-    override fun header(level: Int, block: PageContentBuilderFunction) {
-        contents += ContentHeader(level, group(ContentKind.Symbol, block))
-    }
-
-    override fun text(text: String, kind: Kind) {
-        contents += createText(text, kind)
-    }
-
-    protected fun signature(f: Function, block: PageContentBuilderFunction) {
-        contents += group(setOf(f.dri), f.platformData, ContentKind.Symbol, block)
-    }
-
-    override fun signature(f: Function) = signature(f) {
-        text("fun ")
-        if (f.receiver is Parameter) {
-            type(f.receiver.type)
-            text(".")
-        }
-        link(f.name, f.dri)
-        text("(")
-        list(f.parameters) {
-            link(it.name!!, it.dri)
-            text(": ")
-            type(it.type)
-        }
-        text(")")
-        val returnType = f.returnType
-        if (!f.isConstructor && returnType != null &&
-            returnType.constructorFqName != Unit::class.qualifiedName) {
-            text(": ")
-            type(returnType)
-        }
-    }
-
-    override fun linkTable(elements: List<DRI>) {
-        contents += ContentTable(
-            emptyList(),
-            elements.map { group(dri, platformData, ContentKind.Classes) { link(it.classNames ?: "", it) } },
-            DCI(dri, kind),
-            platformData, styles, extras
-        )
-    }
-
-    override fun <T : Documentable> block(
-        name: String,
-        level: Int,
-        kind: Kind,
-        elements: Iterable<T>,
-        platformData: Set<PlatformData>,
-        operation: PageContentBuilder.(T) -> Unit
-    ) {
-        header(level) { text(name) }
-
-        contents += ContentTable(
-            emptyList(),
-            elements.map { group(setOf(it.dri), it.platformData, kind) { operation(it) } },
-            DCI(dri, kind),
-            platformData, styles, extras
-        )
-    }
-
-    override fun <T> list(
-        elements: List<T>,
-        prefix: String,
-        suffix: String,
-        separator: String,
-        operation: PageContentBuilder.(T) -> Unit
-    ) {
-        if (elements.isNotEmpty()) {
-            if (prefix.isNotEmpty()) text(prefix)
-            elements.dropLast(1).forEach {
-                operation(it)
-                text(separator)
-            }
-            operation(elements.last())
-            if (suffix.isNotEmpty()) text(suffix)
-        }
-    }
-
-    override fun link(text: String, address: DRI, kind: Kind) {
-        contents += ContentDRILink(
-            listOf(createText(text)),
-            address,
-            DCI(dri, kind),
-            platformData
-        )
-    }
-
-    override fun link(address: DRI, kind: Kind, block: PageContentBuilderFunction) {
-        contents += ContentDRILink(
-            group(ContentKind.Main, block).children,
-            address,
-            DCI(dri, kind),
-            platformData
-        )
-    }
-
-    override fun comment(docTag: DocTag) {
-        contents += group(ContentKind.Comment) {
-            with(this as DefaultPageContentBuilder) {
-                contents += commentsConverter.buildContent(
-                    docTag,
-                    DCI(dri, ContentKind.Comment),
-                    platformData
-                )
-            }
-        }
-    }
-
-    fun group(kind: Kind, block: PageContentBuilderFunction): ContentGroup =
-        group(dri, platformData, kind, block)
-
-    override fun group(
-        dri: Set<DRI>,
-        platformData: Set<PlatformData>,
-        kind: Kind,
-        block: PageContentBuilderFunction
-    ): ContentGroup = group(dri, platformData, kind, commentsConverter, logger, block)
-
-    companion object {
-        fun group(
-            dri: Set<DRI>,
-            platformData: Set<PlatformData>,
-            kind: Kind,
-            commentsConverter: CommentsToContentConverter,
-            logger: DokkaLogger,
-            block: PageContentBuilderFunction
-        ): ContentGroup =
-            DefaultPageContentBuilder(dri, platformData, kind, commentsConverter, logger).apply(block).build()
-    }
-}
-
-
-fun PageContentBuilder.type(t: TypeWrapper) {
-    if (t.constructorNamePathSegments.isNotEmpty() && t.dri != null)
-        link(t.constructorNamePathSegments.last(), t.dri!!)
-    else if (t.constructorNamePathSegments.isNotEmpty() && t.dri == null)
-        text(t.toString())
-    else (this as? DefaultPageContentBuilder)?.let {
-        logger.error("type $t cannot be resolved")
-        text("???")
-    }
-    list(t.arguments, prefix = "<", suffix = ">") {
-        type(it)
-    }
-}
-
-typealias PageContentBuilderFunction = PageContentBuilder.() -> Unit
-
-@DslMarker
-annotation class ContentMarker
-
-@ContentMarker
-interface PageContentBuilder {
-    fun group(
-        dri: Set<DRI>,
-        platformData: Set<PlatformData>,
-        kind: Kind, block: PageContentBuilderFunction
-    ): ContentGroup
-    fun text(text: String, kind: Kind = ContentKind.Symbol)
-    fun signature(f: Function)
-    fun link(text: String, address: DRI, kind: Kind = ContentKind.Symbol)
-    fun link(address: DRI, kind: Kind = ContentKind.Symbol, block: PageContentBuilderFunction)
-    fun linkTable(elements: List<DRI>)
-    fun comment(docTag: DocTag)
-    fun header(level: Int, block: PageContentBuilderFunction)
-    fun <T> list(
-        elements: List<T>,
-        prefix: String = "",
-        suffix: String = "",
-        separator: String = ",",
-        operation: PageContentBuilder.(T) -> Unit
-    )
-
-    fun <T : Documentable> block(
-        name: String,
-        level: Int,
-        kind: Kind,
-        elements: Iterable<T>,
-        platformData: Set<PlatformData>,
-        operation: PageContentBuilder.(T) -> Unit
-    )
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index c1a72c74..7c76afe7 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -6,7 +6,6 @@ import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.OutputWriter
 import org.jetbrains.dokka.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
-import org.jetbrains.dokka.transformers.documentation.DefaultDocumentationToPageTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
 import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageNodeMerger
@@ -28,7 +27,6 @@ internal object DefaultExtensions {
         when (point) {
             CoreExtensions.psiToDocumentationTranslator -> DefaultPsiToDocumentationTranslator
             CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
-            CoreExtensions.documentationToPageTranslator -> DefaultDocumentationToPageTranslator
             CoreExtensions.pageTransformer -> DefaultPageNodeMerger(fullContext)
             CoreExtensions.renderer -> renderer.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
diff --git a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
deleted file mode 100644
index c2a21150..00000000
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationToPageTranslator.kt
+++ /dev/null
@@ -1,23 +0,0 @@
-package org.jetbrains.dokka.transformers.documentation
-
-import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.model.Module
-import org.jetbrains.dokka.pages.DefaultPageBuilder
-import org.jetbrains.dokka.pages.DefaultPageContentBuilder
-import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-
-
-object DefaultDocumentationToPageTranslator : DocumentationToPageTranslator {
-    override fun invoke(module: Module, context: DokkaContext): ModulePageNode =
-        DefaultPageBuilder { node, kind, operation ->
-            DefaultPageContentBuilder.group(
-                setOf(node.dri),
-                node.platformData,
-                kind,
-                context.single(CoreExtensions.commentsToContentConverter),
-                context.logger,
-                operation
-            )
-        }.pageForModule(module)
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentablesToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DocumentablesToPageTranslator.kt
new file mode 100644
index 00000000..fa74d216
--- /dev/null
+++ b/core/src/main/kotlin/transformers/documentation/DocumentablesToPageTranslator.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.dokka.transformers.documentation
+
+import org.jetbrains.dokka.model.Module
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+
+interface DocumentablesToPageTranslator {
+    operator fun invoke(module: Module, context: DokkaContext): ModulePageNode
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
deleted file mode 100644
index 08c26b19..00000000
--- a/core/src/main/kotlin/transformers/documentation/DocumentationToPageTranslator.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package org.jetbrains.dokka.transformers.documentation
-
-import org.jetbrains.dokka.model.Module
-import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-
-interface DocumentationToPageTranslator {
-    operator fun invoke(module: Module, context: DokkaContext): ModulePageNode
-}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index b18e2ad5..34c0ffae 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -3,14 +3,19 @@ package org.jetbrains.dokka.base
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.base.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentableMerger
+import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentablesToPageTranslator
 import org.jetbrains.dokka.plugability.DokkaPlugin
 
 class DokkaBase: DokkaPlugin() {
-    val defaultDescriptorToDocumentationTranslator by extending(isFallback = true) {
+    val descriptorToDocumentationTranslator by extending(isFallback = true) {
         CoreExtensions.descriptorToDocumentationTranslator providing ::DefaultDescriptorToDocumentationTranslator
     }
 
-    val defaultDocumentableMerger by extending(isFallback = true) {
+    val documentableMerger by extending(isFallback = true) {
         CoreExtensions.documentableMerger with DefaultDocumentableMerger
     }
+
+    val documentablesToPageTranslator by extending(isFallback = true) {
+        CoreExtensions.documentablesToPageTranslator with DefaultDocumentablesToPageTranslator
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt
new file mode 100644
index 00000000..90f8e2d7
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt
@@ -0,0 +1,22 @@
+package org.jetbrains.dokka.base.transformers.documentables
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.model.Module
+import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.transformers.documentation.DocumentablesToPageTranslator
+
+
+object DefaultDocumentablesToPageTranslator : DocumentablesToPageTranslator {
+    override fun invoke(module: Module, context: DokkaContext): ModulePageNode =
+        DefaultPageBuilder { node, kind, operation ->
+            DefaultPageContentBuilder.group(
+                setOf(node.dri),
+                node.platformData,
+                kind,
+                context.single(CoreExtensions.commentsToContentConverter),
+                context.logger,
+                operation
+            )
+        }.pageForModule(module)
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/PageBuilder.kt b/plugins/base/src/main/kotlin/transformers/documentables/PageBuilder.kt
new file mode 100644
index 00000000..29f39c73
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/documentables/PageBuilder.kt
@@ -0,0 +1,159 @@
+package org.jetbrains.dokka.base.transformers.documentables
+
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Enum
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.model.doc.TagWrapper
+import org.jetbrains.dokka.pages.*
+
+open class DefaultPageBuilder(
+    override val rootContentGroup: RootContentBuilder
+) : PageBuilder {
+
+    override fun pageForModule(m: Module): ModulePageNode =
+        ModulePageNode(m.name.ifEmpty { "root" }, contentForModule(m), m, m.packages.map { pageForPackage(it) })
+
+    override fun pageForPackage(p: Package) =
+        PackagePageNode(p.name, contentForPackage(p), setOf(p.dri), p,
+            p.classlikes.map { pageForClasslike(it) } +
+                    p.functions.map { pageForMember(it) })
+
+    override fun pageForClasslike(c: Classlike): ClasslikePageNode {
+        val constructors = when (c) {
+            is Class -> c.constructors
+            is Enum -> c.constructors
+            else -> emptyList()
+        }
+
+        return ClasslikePageNode(c.name, contentForClasslike(c), setOf(c.dri), c,
+            constructors.map { pageForMember(it) } +
+                    c.classlikes.map { pageForClasslike(it) } +
+                    c.functions.map { pageForMember(it) })
+    }
+
+    override fun pageForMember(m: CallableNode): MemberPageNode =
+        when (m) {
+            is Function ->
+                MemberPageNode(m.name, contentForFunction(m), setOf(m.dri), m)
+            else -> throw IllegalStateException("$m should not be present here")
+        }
+
+    protected open fun group(node: Documentable, content: PageContentBuilderFunction) =
+        rootContentGroup(node, ContentKind.Main, content)
+
+    protected open fun contentForModule(m: Module) = group(m) {
+        header(1) { text("root") }
+        block("Packages", 2, ContentKind.Packages, m.packages, m.platformData) {
+            link(it.name, it.dri)
+        }
+        text("Index\n")
+        text("Link to allpage here")
+    }
+
+    protected open fun contentForPackage(p: Package) = group(p) {
+        header(1) { text("Package ${p.name}") }
+        block("Types", 2, ContentKind.Properties, p.classlikes, p.platformData) {
+            link(it.name, it.dri)
+            text(it.briefDocTagString)
+        }
+        block("Functions", 2, ContentKind.Functions, p.functions, p.platformData) {
+            link(it.name, it.dri)
+            signature(it)
+            text(it.briefDocTagString)
+        }
+    }
+
+    open fun contentForClasslike(c: Classlike): ContentGroup = when (c) {
+        is Class -> contentForClass(c)
+        is Enum -> contentForEnum(c)
+        else -> throw IllegalStateException("$c should not be present here")
+    }
+
+    protected fun contentForClass(c: Class) = group(c) {
+        header(1) { text(c.name) }
+
+        c.inherited.takeIf { it.isNotEmpty() }?.let {
+            header(2) { text("SuperInterfaces") }
+            linkTable(it)
+        }
+        contentForComments(c)
+        block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) {
+            link(it.name, it.dri)
+            signature(it)
+            text(it.briefDocTagString)
+        }
+        block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) {
+            link(it.name, it.dri)
+            signature(it)
+            text(it.briefDocTagString)
+        }
+        block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) {
+            link(it.name, it.dri)
+            text(it.briefDocTagString)
+
+        }
+    }
+
+    fun contentForEnum(c: Enum): ContentGroup = group(c) {
+        header(1) { text("enum ${c.name}") }
+
+        block("Entries", 2, ContentKind.Properties, c.entries, c.platformData) { entry ->
+            link(entry.name, entry.dri)
+            contentForComments(entry)
+        }
+
+        c.inherited.takeIf { it.isNotEmpty() }?.let {
+            header(2) { text("SuperInterfaces") }
+            linkTable(it)
+        }
+        contentForComments(c)
+        block("Constructors", 2, ContentKind.Functions, c.constructors, c.platformData) {
+            link(it.name, it.dri)
+            signature(it)
+            text(it.briefDocTagString)
+        }
+        block("Functions", 2, ContentKind.Functions, c.functions, c.platformData) {
+            link(it.name, it.dri)
+            signature(it)
+            text(it.briefDocTagString)
+        }
+        block("Properties", 2, ContentKind.Properties, c.properties, c.platformData) {
+            link(it.name, it.dri)
+            text(it.briefDocTagString)
+        }
+    }
+
+    private fun PageContentBuilder.contentForComments(d: Documentable) =
+        d.platformInfo.forEach { platformInfo ->
+            platformInfo.documentationNode.children.forEach {
+                header(3) {
+                    text(it.toHeaderString())
+                    text(" [${platformInfo.platformData.joinToString(", ") { it.platformType.name }}]")
+                }
+                comment(it.root)
+                text("\n")
+            }
+        }
+
+    private fun contentForFunction(f: Function) = group(f) {
+        header(1) { text(f.name) }
+        signature(f)
+        contentForComments(f)
+        block("Parameters", 2, ContentKind.Parameters, f.children, f.platformData) {
+            text(it.name ?: "<receiver>")
+            it.platformInfo.forEach { it.documentationNode.children.forEach { comment(it.root) } }
+        }
+    }
+
+    private fun TagWrapper.toHeaderString() = this.javaClass.toGenericString().split('.').last()
+}
+
+typealias RootContentBuilder = (Documentable, Kind, PageContentBuilderFunction) -> ContentGroup
+
+interface PageBuilder {
+    val rootContentGroup: RootContentBuilder
+    fun pageForModule(m: Module): ModulePageNode
+    fun pageForPackage(p: Package): PackagePageNode
+    fun pageForMember(m: CallableNode): MemberPageNode
+    fun pageForClasslike(c: Classlike): ClasslikePageNode
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt
new file mode 100644
index 00000000..809b97a0
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt
@@ -0,0 +1,217 @@
+package org.jetbrains.dokka.base.transformers.documentables
+
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.model.TypeWrapper
+import org.jetbrains.dokka.model.doc.DocTag
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.utilities.DokkaLogger
+
+open class DefaultPageContentBuilder(
+    protected val dri: Set<DRI>,
+    protected val platformData: Set<PlatformData>,
+    protected val kind: Kind,
+    protected val commentsConverter: CommentsToContentConverter,
+    val logger: DokkaLogger,
+    protected val styles: Set<Style> = emptySet(),
+    protected val extras: Set<Extra> = emptySet()
+) : PageContentBuilder {
+    protected val contents = mutableListOf<ContentNode>()
+
+    protected fun createText(text: String, kind: Kind = ContentKind.Symbol) =
+        ContentText(text, DCI(dri, kind), platformData, styles, extras)
+
+    protected fun build() = ContentGroup(
+        contents.toList(),
+        DCI(dri, kind),
+        platformData,
+        styles,
+        extras
+    )
+
+    override fun header(level: Int, block: PageContentBuilderFunction) {
+        contents += ContentHeader(level, group(ContentKind.Symbol, block))
+    }
+
+    override fun text(text: String, kind: Kind) {
+        contents += createText(text, kind)
+    }
+
+    protected fun signature(f: Function, block: PageContentBuilderFunction) {
+        contents += group(setOf(f.dri), f.platformData, ContentKind.Symbol, block)
+    }
+
+    override fun signature(f: Function) = signature(f) {
+        text("fun ")
+        f.receiver?.also {
+            type(it.type)
+            text(".")
+        }
+        link(f.name, f.dri)
+        text("(")
+        list(f.parameters) {
+            link(it.name!!, it.dri)
+            text(": ")
+            type(it.type)
+        }
+        text(")")
+        val returnType = f.returnType
+        if (!f.isConstructor && returnType != null &&
+            returnType.constructorFqName != Unit::class.qualifiedName
+        ) {
+            text(": ")
+            type(returnType)
+        }
+    }
+
+    override fun linkTable(elements: List<DRI>) {
+        contents += ContentTable(
+            emptyList(),
+            elements.map { group(dri, platformData, ContentKind.Classes) { link(it.classNames ?: "", it) } },
+            DCI(dri, kind),
+            platformData, styles, extras
+        )
+    }
+
+    override fun <T : Documentable> block(
+        name: String,
+        level: Int,
+        kind: Kind,
+        elements: Iterable<T>,
+        platformData: Set<PlatformData>,
+        operation: PageContentBuilder.(T) -> Unit
+    ) {
+        header(level) { text(name) }
+
+        contents += ContentTable(
+            emptyList(),
+            elements.map { group(setOf(it.dri), it.platformData, kind) { operation(it) } },
+            DCI(dri, kind),
+            platformData, styles, extras
+        )
+    }
+
+    override fun <T> list(
+        elements: List<T>,
+        prefix: String,
+        suffix: String,
+        separator: String,
+        operation: PageContentBuilder.(T) -> Unit
+    ) {
+        if (elements.isNotEmpty()) {
+            if (prefix.isNotEmpty()) text(prefix)
+            elements.dropLast(1).forEach {
+                operation(it)
+                text(separator)
+            }
+            operation(elements.last())
+            if (suffix.isNotEmpty()) text(suffix)
+        }
+    }
+
+    override fun link(text: String, address: DRI, kind: Kind) {
+        contents += ContentDRILink(
+            listOf(createText(text)),
+            address,
+            DCI(dri, kind),
+            platformData
+        )
+    }
+
+    override fun link(address: DRI, kind: Kind, block: PageContentBuilderFunction) {
+        contents += ContentDRILink(
+            group(ContentKind.Main, block).children,
+            address,
+            DCI(dri, kind),
+            platformData
+        )
+    }
+
+    override fun comment(docTag: DocTag) {
+        contents += group(ContentKind.Comment) {
+            with(this as DefaultPageContentBuilder) {
+                contents += commentsConverter.buildContent(
+                    docTag,
+                    DCI(dri, ContentKind.Comment),
+                    platformData
+                )
+            }
+        }
+    }
+
+    fun group(kind: Kind, block: PageContentBuilderFunction): ContentGroup =
+        group(dri, platformData, kind, block)
+
+    override fun group(
+        dri: Set<DRI>,
+        platformData: Set<PlatformData>,
+        kind: Kind,
+        block: PageContentBuilderFunction
+    ): ContentGroup = group(dri, platformData, kind, commentsConverter, logger, block)
+
+    companion object {
+        fun group(
+            dri: Set<DRI>,
+            platformData: Set<PlatformData>,
+            kind: Kind,
+            commentsConverter: CommentsToContentConverter,
+            logger: DokkaLogger,
+            block: PageContentBuilderFunction
+        ): ContentGroup =
+            DefaultPageContentBuilder(dri, platformData, kind, commentsConverter, logger).apply(block).build()
+    }
+}
+
+
+fun PageContentBuilder.type(t: TypeWrapper) {
+    if (t.constructorNamePathSegments.isNotEmpty() && t.dri != null)
+        link(t.constructorNamePathSegments.last(), t.dri!!)
+    else if (t.constructorNamePathSegments.isNotEmpty() && t.dri == null)
+        text(t.toString())
+    else (this as? DefaultPageContentBuilder)?.let {
+        logger.error("type $t cannot be resolved")
+        text("???")
+    }
+    list(t.arguments, prefix = "<", suffix = ">") {
+        type(it)
+    }
+}
+
+typealias PageContentBuilderFunction = PageContentBuilder.() -> Unit
+
+@DslMarker
+annotation class ContentMarker
+
+@ContentMarker
+interface PageContentBuilder {
+    fun group(
+        dri: Set<DRI>,
+        platformData: Set<PlatformData>,
+        kind: Kind, block: PageContentBuilderFunction
+    ): ContentGroup
+
+    fun text(text: String, kind: Kind = ContentKind.Symbol)
+    fun signature(f: Function)
+    fun link(text: String, address: DRI, kind: Kind = ContentKind.Symbol)
+    fun link(address: DRI, kind: Kind = ContentKind.Symbol, block: PageContentBuilderFunction)
+    fun linkTable(elements: List<DRI>)
+    fun comment(docTag: DocTag)
+    fun header(level: Int, block: PageContentBuilderFunction)
+    fun <T> list(
+        elements: List<T>,
+        prefix: String = "",
+        suffix: String = "",
+        separator: String = ",",
+        operation: PageContentBuilder.(T) -> Unit
+    )
+
+    fun <T : Documentable> block(
+        name: String,
+        level: Int,
+        kind: Kind,
+        elements: Iterable<T>,
+        platformData: Set<PlatformData>,
+        operation: PageContentBuilder.(T) -> Unit
+    )
+}
\ No newline at end of file
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageBuilder.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageBuilder.kt
index 6fe10ce1..d4dfdaea 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageBuilder.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageBuilder.kt
@@ -1,5 +1,7 @@
 package org.jetbrains.dokka.kotlinAsJava
 
+import org.jetbrains.dokka.base.transformers.documentables.DefaultPageBuilder
+import org.jetbrains.dokka.base.transformers.documentables.RootContentBuilder
 import org.jetbrains.dokka.kotlinAsJava.conversions.asJava
 import org.jetbrains.dokka.kotlinAsJava.conversions.asStatic
 import org.jetbrains.dokka.kotlinAsJava.conversions.withClass
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
index a5d0bd33..02e6ff82 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
@@ -1,5 +1,8 @@
 package org.jetbrains.dokka.kotlinAsJava
 
+import org.jetbrains.dokka.base.transformers.documentables.DefaultPageContentBuilder
+import org.jetbrains.dokka.base.transformers.documentables.PageContentBuilderFunction
+import org.jetbrains.dokka.base.transformers.documentables.type
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.model.JavaTypeWrapper
@@ -7,13 +10,13 @@ import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.utilities.DokkaLogger
 
 class KotlinAsJavaPageContentBuilder(
-    private val dri: Set<DRI>,
-    private val platformData: Set<PlatformData>,
-    private val kind: Kind,
-    private val commentsConverter: CommentsToContentConverter,
-    override val logger: DokkaLogger,
-    private val styles: Set<Style> = emptySet(),
-    private val extras: Set<Extra> = emptySet()
+    dri: Set<DRI>,
+    platformData: Set<PlatformData>,
+    kind: Kind,
+    commentsConverter: CommentsToContentConverter,
+    logger: DokkaLogger,
+    styles: Set<Style> = emptySet(),
+    extras: Set<Extra> = emptySet()
 ) : DefaultPageContentBuilder(dri, platformData, kind, commentsConverter, logger, styles, extras) {
 
     override fun signature(f: Function) = signature(f) {
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
index dd95f00e..f8a25aca 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
@@ -7,7 +7,7 @@ import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.transformers.documentation.DocumentationToPageTranslator
+import org.jetbrains.dokka.transformers.documentation.DocumentablesToPageTranslator
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 
 class KotlinAsJavaPlugin : DokkaPlugin() {
@@ -15,7 +15,7 @@ class KotlinAsJavaPlugin : DokkaPlugin() {
         CoreExtensions.descriptorToDocumentationTranslator providing ::KotlinAsJavaDescriptorToDocumentationTranslator
     }
     val kotlinAsJavaDocumentableToPageTranslator by extending {
-        CoreExtensions.documentationToPageTranslator with KotlinAsJavaDocumentationToPageTranslator
+        CoreExtensions.documentablesToPageTranslator with KotlinAsJavaDocumentationToPageTranslator
     }
 }
 
@@ -26,7 +26,7 @@ object DescriptorCache {
     operator fun get(dri: DRI): DeclarationDescriptor? = cache[dri]
 }
 
-object KotlinAsJavaDocumentationToPageTranslator : DocumentationToPageTranslator {
+object KotlinAsJavaDocumentationToPageTranslator : DocumentablesToPageTranslator {
     override fun invoke(module: Module, context: DokkaContext): ModulePageNode =
         KotlinAsJavaPageBuilder { node, kind, operation ->
             KotlinAsJavaPageContentBuilder.group(
-- 
cgit 


From f625cef495d625d81ee22e950083f57cc4fab875 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 17 Feb 2020 09:32:35 +0100
Subject: Moves PsiToDocumentablesTranslator to the base plugin

---
 core/build.gradle.kts                              |   1 -
 core/src/main/kotlin/CoreExtensions.kt             |   5 +-
 .../main/kotlin/plugability/DefaultExtensions.kt   |  10 -
 core/src/main/kotlin/renderers/DefaultRenderer.kt  | 124 ------------
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt | 217 ---------------------
 .../main/kotlin/renderers/html/NavigationPage.kt   |  50 -----
 .../kotlin/renderers/html/htmlPreprocessors.kt     |  68 -------
 .../psi/DefaultPsiToDocumentationTranslator.kt     | 143 --------------
 plugins/base/build.gradle.kts                      |   4 +
 plugins/base/src/main/kotlin/DokkaBase.kt          |  10 +
 .../src/main/kotlin/renderers/DefaultRenderer.kt   | 127 ++++++++++++
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt | 216 ++++++++++++++++++++
 .../main/kotlin/renderers/html/NavigationPage.kt   |  50 +++++
 .../kotlin/renderers/html/htmlPreprocessors.kt     |  68 +++++++
 .../psi/DefaultPsiToDocumentationTranslator.kt     | 145 ++++++++++++++
 15 files changed, 623 insertions(+), 615 deletions(-)
 delete mode 100644 core/src/main/kotlin/renderers/DefaultRenderer.kt
 delete mode 100644 core/src/main/kotlin/renderers/html/HtmlRenderer.kt
 delete mode 100644 core/src/main/kotlin/renderers/html/NavigationPage.kt
 delete mode 100644 core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
 delete mode 100644 core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
 create mode 100644 plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
 create mode 100644 plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
 create mode 100644 plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
 create mode 100644 plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index fbe9d563..365cf7e8 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -10,7 +10,6 @@ dependencies {
 
     val kotlin_version: String by project
     api("org.jetbrains.kotlin:kotlin-compiler:$kotlin_version")
-    implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
     implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
     implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlin_version")
     implementation("org.jsoup:jsoup:1.12.1")
diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 8ae333ee..2d705c1b 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -24,12 +24,13 @@ object CoreExtensions {
     val psiToDocumentationTranslator by coreExtension<PsiToDocumentationTranslator>()
     val documentableMerger by coreExtension<DocumentableMerger>()
     val documentationTransformer by coreExtension<DocumentationNodeTransformer>()
-    val commentsToContentConverter by coreExtension<CommentsToContentConverter>()
     val documentablesToPageTranslator by coreExtension<DocumentablesToPageTranslator>()
     val pageTransformer by coreExtension<PageNodeTransformer>()
+    val renderer by coreExtension<Renderer>()
+
+    val commentsToContentConverter by coreExtension<CommentsToContentConverter>()
     val locationProviderFactory by coreExtension<LocationProviderFactory>()
     val outputWriter by coreExtension<OutputWriter>()
-    val renderer by coreExtension<Renderer>()
     val pageMergerStrategy by coreExtension<PageMergerStrategy>()
 
     private fun <T: Any> coreExtension() = object {
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 7c76afe7..828d1bf1 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -4,20 +4,12 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.DocTagToContentConverter
 import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.OutputWriter
-import org.jetbrains.dokka.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
 import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
-import org.jetbrains.dokka.transformers.psi.DefaultPsiToDocumentationTranslator
 import org.jetbrains.dokka.transformers.pages.DefaultPageNodeMerger
 
 internal object DefaultExtensions {
 
-    private val renderer: LazyEvaluated<HtmlRenderer> = LazyEvaluated.fromRecipe {
-        HtmlRenderer(
-            it.single(CoreExtensions.outputWriter),
-            it
-        )
-    }
     private val converter: LazyEvaluated<DocTagToContentConverter> = LazyEvaluated.fromRecipe { DocTagToContentConverter(it) }
     private val providerFactory: LazyEvaluated<DefaultLocationProviderFactory> = LazyEvaluated.fromRecipe { DefaultLocationProviderFactory(it) }
     private val outputWriter: LazyEvaluated<OutputWriter> = LazyEvaluated.fromRecipe { FileWriter(it) }
@@ -25,10 +17,8 @@ internal object DefaultExtensions {
     @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
-            CoreExtensions.psiToDocumentationTranslator -> DefaultPsiToDocumentationTranslator
             CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
             CoreExtensions.pageTransformer -> DefaultPageNodeMerger(fullContext)
-            CoreExtensions.renderer -> renderer.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
             CoreExtensions.outputWriter ->  outputWriter.get(fullContext)
             CoreExtensions.pageMergerStrategy -> DefaultPageMergerStrategy(fullContext.logger)
diff --git a/core/src/main/kotlin/renderers/DefaultRenderer.kt b/core/src/main/kotlin/renderers/DefaultRenderer.kt
deleted file mode 100644
index d09d9ded..00000000
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ /dev/null
@@ -1,124 +0,0 @@
-package org.jetbrains.dokka.renderers
-
-import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.resolvers.LocationProvider
-import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
-
-abstract class DefaultRenderer<T>(
-    protected val outputWriter: OutputWriter,
-    protected val context: DokkaContext
-) : Renderer {
-
-    protected lateinit var locationProvider: LocationProvider
-        private set
-
-    protected open val preprocessors: Iterable<PageNodeTransformer> = emptyList()
-
-    abstract fun T.buildHeader(level: Int, content: T.() -> Unit)
-    abstract fun T.buildLink(address: String, content: T.() -> Unit)
-    abstract fun T.buildList(node: ContentList, pageContext: ContentPage)
-    abstract fun T.buildNewLine()
-    abstract fun T.buildResource(node: ContentEmbeddedResource, pageContext: ContentPage)
-    abstract fun T.buildTable(node: ContentTable, pageContext: ContentPage)
-    abstract fun T.buildText(textNode: ContentText)
-    abstract fun T.buildNavigation(page: PageNode)
-
-    abstract fun buildPage(page: ContentPage, content: (T, ContentPage) -> Unit): String
-    abstract fun buildError(node: ContentNode)
-
-    open fun T.buildGroup(node: ContentGroup, pageContext: ContentPage) {
-        node.children.forEach { it.build(this, pageContext) }
-    }
-
-    open fun T.buildLinkText(nodes: List<ContentNode>, pageContext: ContentPage) {
-        nodes.forEach { it.build(this, pageContext) }
-    }
-
-    open fun T.buildCode(code: List<ContentNode>, language: String, pageContext: ContentPage) {
-        code.forEach { it.build(this, pageContext) }
-    }
-
-    open fun T.buildHeader(node: ContentHeader, pageContext: ContentPage) {
-        buildHeader(node.level) { node.children.forEach { it.build(this, pageContext) } }
-    }
-
-    open fun ContentNode.build(builder: T, pageContext: ContentPage) =
-        builder.buildContentNode(this, pageContext)
-
-    open fun T.buildContentNode(node: ContentNode, pageContext: ContentPage) {
-        when (node) {
-            is ContentText -> buildText(node)
-            is ContentHeader -> buildHeader(node, pageContext)
-            is ContentCode -> buildCode(node.children, node.language, pageContext)
-            is ContentDRILink -> buildLink(
-                locationProvider.resolve(node.address, node.platforms.toList(), pageContext)
-            ) {
-                buildLinkText(node.children, pageContext)
-            }
-            is ContentResolvedLink -> buildLink(node.address) { buildLinkText(node.children, pageContext) }
-            is ContentEmbeddedResource -> buildResource(node, pageContext)
-            is ContentList -> buildList(node, pageContext)
-            is ContentTable -> buildTable(node, pageContext)
-            is ContentGroup -> buildGroup(node, pageContext)
-            else -> buildError(node)
-        }
-    }
-
-    open fun buildPageContent(context: T, page: ContentPage) {
-        context.buildNavigation(page)
-        page.content.build(context, page)
-    }
-
-    open fun renderPage(page: PageNode) {
-        val path by lazy { locationProvider.resolve(page, skipExtension = true) }
-        when (page) {
-            is ContentPage -> outputWriter.write(path, buildPage(page) { c, p -> buildPageContent(c, p) }, ".html")
-            is RendererSpecificPage -> when (val strategy = page.strategy) {
-                is RenderingStrategy.Copy -> outputWriter.writeResources(strategy.from, path)
-                is RenderingStrategy.Write -> outputWriter.write(path, strategy.text, "")
-                is RenderingStrategy.Callback -> outputWriter.write(path, strategy.instructions(this, page), ".html")
-                RenderingStrategy.DoNothing -> Unit
-            }
-            else -> throw AssertionError(
-                "Page ${page.name} cannot be rendered by renderer as it is not renderer specific nor contains content"
-            )
-        }
-    }
-
-    open fun renderPages(root: PageNode) {
-        renderPage(root)
-        root.children.forEach { renderPages(it) }
-    }
-
-    // reimplement this as preprocessor
-    open fun renderPackageList(root: ContentPage) =
-        getPackageNamesAndPlatforms(root)
-            .keys
-            .joinToString("\n")
-            .also { outputWriter.write("${root.name}/package-list", it, "") }
-
-    open fun getPackageNamesAndPlatforms(root: PageNode): Map<String, List<PlatformData>> =
-        root.children
-            .map(::getPackageNamesAndPlatforms)
-            .fold(emptyMap<String, List<PlatformData>>()) { e, acc -> acc + e } +
-                if (root is PackagePageNode) {
-                    mapOf(root.name to root.platforms())
-                } else {
-                    emptyMap()
-                }
-
-    override fun render(root: RootPageNode) {
-        val newRoot = preprocessors.fold(root) { acc, t -> t(acc) }
-
-        locationProvider =
-            context.single(CoreExtensions.locationProviderFactory).getLocationProvider(newRoot)
-
-        root.children<ModulePageNode>().forEach { renderPackageList(it) }
-
-        renderPages(newRoot)
-    }
-}
-
-fun ContentPage.platforms() = this.content.platforms.toList()
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
deleted file mode 100644
index 376ce5c8..00000000
--- a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ /dev/null
@@ -1,217 +0,0 @@
-package org.jetbrains.dokka.renderers.html
-
-import kotlinx.html.*
-import kotlinx.html.stream.createHTML
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.Function
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.renderers.DefaultRenderer
-import org.jetbrains.dokka.renderers.OutputWriter
-import java.io.File
-
-open class HtmlRenderer(
-    outputWriter: OutputWriter,
-    context: DokkaContext
-) : DefaultRenderer<FlowContent>(outputWriter, context) {
-
-    private val pageList = mutableListOf<String>()
-
-    override val preprocessors = listOf(
-        RootCreator,
-        SearchPageInstaller,
-        ResourceInstaller,
-        NavigationPageInstaller,
-        StyleAndScriptsAppender
-    )
-
-    override fun FlowContent.buildList(node: ContentList, pageContext: ContentPage) =
-        if (node.ordered) ol {
-            buildListItems(node.children, pageContext)
-        }
-        else ul {
-            buildListItems(node.children, pageContext)
-        }
-
-    open fun OL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
-        items.forEach {
-            if (it is ContentList)
-                buildList(it, pageContext)
-            else
-                li { it.build(this, pageContext) }
-        }
-    }
-
-    open fun UL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
-        items.forEach {
-            if (it is ContentList)
-                buildList(it, pageContext)
-            else
-                li { it.build(this, pageContext) }
-        }
-    }
-
-    override fun FlowContent.buildResource(
-        node: ContentEmbeddedResource,
-        pageContext: ContentPage
-    ) { // TODO: extension point there
-        val imageExtensions = setOf("png", "jpg", "jpeg", "gif", "bmp", "tif", "webp", "svg")
-        return if (File(node.address).extension.toLowerCase() in imageExtensions) {
-            //TODO: add imgAttrs parsing
-            val imgAttrs = node.extras.filterIsInstance<HTMLSimpleAttr>().joinAttr()
-            img(src = node.address, alt = node.altText)
-        } else {
-            println("Unrecognized resource type: $node")
-        }
-    }
-
-    override fun FlowContent.buildTable(node: ContentTable, pageContext: ContentPage) {
-        table {
-            thead {
-                node.header.forEach {
-                    tr {
-                        it.children.forEach {
-                            th {
-                                it.build(this@table, pageContext)
-                            }
-                        }
-                    }
-                }
-            }
-            tbody {
-                node.children.forEach {
-                    tr {
-                        it.children.forEach {
-                            td {
-                                it.build(this, pageContext)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    override fun FlowContent.buildHeader(level: Int, content: FlowContent.() -> Unit) {
-        when (level) {
-            1 -> h1(block = content)
-            2 -> h2(block = content)
-            3 -> h3(block = content)
-            4 -> h4(block = content)
-            5 -> h5(block = content)
-            else -> h6(block = content)
-        }
-    }
-
-    override fun FlowContent.buildNavigation(page: PageNode) =
-        locationProvider.ancestors(page).asReversed().forEach { node ->
-            text("/")
-            if (node.isNavigable) buildLink(node, page)
-            else text(node.name)
-        }
-
-    private fun FlowContent.buildLink(to: PageNode, from: PageNode) =
-        buildLink(locationProvider.resolve(to, from)) {
-            text(to.name)
-        }
-
-    fun FlowContent.buildLink(
-        to: DRI,
-        platforms: List<PlatformData>,
-        from: PageNode? = null,
-        block: FlowContent.() -> Unit
-    ) = buildLink(locationProvider.resolve(to, platforms, from), block)
-
-    override fun buildError(node: ContentNode) {
-        context.logger.error("Unknown ContentNode type: $node")
-    }
-
-    override fun FlowContent.buildNewLine() {
-        br()
-    }
-
-    override fun FlowContent.buildLink(address: String, content: FlowContent.() -> Unit) =
-        a(href = address, block = content)
-
-    override fun FlowContent.buildCode(code: List<ContentNode>, language: String, pageContext: ContentPage) {
-        buildNewLine()
-        code.forEach {
-            +((it as? ContentText)?.text ?: run { context.logger.error("Cannot cast $it as ContentText!"); "" })
-            buildNewLine()
-        }
-    }
-
-    override fun renderPage(page: PageNode) {
-        super.renderPage(page)
-        if (page is ContentPage) {
-            pageList.add(
-                """{ "name": "${page.name}", ${if (page is ClasslikePageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(
-                    page
-                )}" }"""
-            )
-        }
-    }
-
-    override fun FlowContent.buildText(textNode: ContentText) {
-        text(textNode.text)
-    }
-
-    override fun render(root: RootPageNode) {
-        super.render(root)
-        outputWriter.write("scripts/pages", "var pages = [\n${pageList.joinToString(",\n")}\n]", ".js")
-    }
-
-    private fun PageNode.root(path: String) = locationProvider.resolveRoot(this) + path
-
-    override fun buildPage(page: ContentPage, content: (FlowContent, ContentPage) -> Unit): String =
-        buildHtml(page, page.embeddedResources) { content(this, page) }
-
-    open fun buildHtml(page: PageNode, resources: List<String>, content: FlowContent.() -> Unit) =
-        createHTML().html {
-            head {
-                title(page.name)
-                with(resources) {
-                    filter { it.substringBefore('?').substringAfterLast('.') == "css" }
-                        .forEach { link(rel = LinkRel.stylesheet, href = page.root(it)) }
-                    filter { it.substringBefore('?').substringAfterLast('.') == "js" }
-                        .forEach { script(type = ScriptType.textJavaScript, src = page.root(it)) { async = true } }
-                }
-                script { unsafe { +"""var pathToRoot = "${locationProvider.resolveRoot(page)}";""" } }
-            }
-            body {
-                div {
-                    id = "navigation"
-                    div {
-                        id = "searchBar"
-                        form(action = page.root("-search.html"), method = FormMethod.get) {
-                            id = "searchForm"
-                            input(type = InputType.search, name = "query")
-                            input(type = InputType.submit) { value = "Search" }
-                        }
-                    }
-                    div {
-                        id = "sideMenu"
-                    }
-                }
-                div {
-                    id = "content"
-                    content()
-                }
-            }
-        }
-}
-
-fun List<HTMLMetadata>.joinAttr() = joinToString(" ") { it.key + "=" + it.value }
-
-private fun PageNode.pageKind() = when (this) {
-    is PackagePageNode -> "package"
-    is ClasslikePageNode -> "class"
-    is MemberPageNode -> when (this.documentable) {
-        is Function -> "function"
-        else -> "other"
-    }
-    else -> "other"
-}
-
-private val PageNode.isNavigable: Boolean
-    get() = this !is RendererSpecificPage || strategy != RenderingStrategy.DoNothing
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/html/NavigationPage.kt b/core/src/main/kotlin/renderers/html/NavigationPage.kt
deleted file mode 100644
index 4a2fb40d..00000000
--- a/core/src/main/kotlin/renderers/html/NavigationPage.kt
+++ /dev/null
@@ -1,50 +0,0 @@
-package org.jetbrains.dokka.renderers.html
-
-import kotlinx.html.*
-import kotlinx.html.stream.createHTML
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.dokka.pages.RendererSpecificPage
-import org.jetbrains.dokka.pages.RenderingStrategy
-
-class NavigationPage(val root: NavigationNode) : RendererSpecificPage {
-    override val name = "navigation"
-
-    override val children = emptyList<PageNode>()
-
-    override fun modified(name: String, children: List<PageNode>) = this
-
-    override val strategy = RenderingStrategy<HtmlRenderer> {
-        createHTML().visit(root, "nav-submenu", this)
-    }
-
-    private fun <R> TagConsumer<R>.visit(node: NavigationNode, navId: String, renderer: HtmlRenderer): R =
-        with(renderer) {
-            div("sideMenuPart") {
-                id = navId
-                div("overview") {
-                    buildLink(node.dri, node.platforms) { +node.name }
-                    if (node.children.isNotEmpty()) {
-                        span("navButton") {
-                            onClick = """document.getElementById("$navId").classList.toggle("hidden");"""
-                            span("navButtonContent")
-                        }
-                    }
-                }
-                node.children.withIndex().forEach { (n, p) -> visit(p, "$navId-$n", renderer) }
-            }
-        }
-}
-
-class NavigationNode(
-    val name: String,
-    val dri: DRI,
-    val platforms: List<PlatformData>,
-    val children: List<NavigationNode>
-)
-
-fun NavigationPage.transform(block: (NavigationNode) -> NavigationNode) = NavigationPage(root.transform(block))
-
-fun NavigationNode.transform(block: (NavigationNode) -> NavigationNode) =
-    run(block).let { NavigationNode(it.name, it.dri, it.platforms, it.children.map(block)) }
diff --git a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
deleted file mode 100644
index 4ee67448..00000000
--- a/core/src/main/kotlin/renderers/html/htmlPreprocessors.kt
+++ /dev/null
@@ -1,68 +0,0 @@
-package org.jetbrains.dokka.renderers.html
-
-import kotlinx.html.h1
-import kotlinx.html.id
-import kotlinx.html.table
-import kotlinx.html.tbody
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.renderers.platforms
-import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
-
-object RootCreator : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) =
-        RendererSpecificRootPage("", listOf(input), RenderingStrategy.DoNothing)
-}
-
-object SearchPageInstaller : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) = input.modified(children = input.children + searchPage)
-
-    private val searchPage = RendererSpecificResourcePage(
-        name = "Search",
-        children = emptyList(),
-        strategy = RenderingStrategy<HtmlRenderer> {
-            buildHtml(it, listOf("styles/style.css", "scripts/pages.js")) {
-                h1 {
-                    id = "searchTitle"
-                    text("Search results for ")
-                }
-                table {
-                    tbody {
-                        id = "searchTable"
-                    }
-                }
-            }
-        })
-}
-
-object NavigationPageInstaller : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) = input.modified(
-        children = input.children + NavigationPage(
-            input.children.filterIsInstance<ContentPage>().single().let(::visit)
-        )
-    )
-
-    private fun visit(page: ContentPage): NavigationNode = NavigationNode(
-        page.name,
-        page.dri.first(),
-        page.platforms(),
-        page.children.filterIsInstance<ContentPage>().map { visit(it) })
-}
-
-object ResourceInstaller : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) = input.modified(children = input.children + resourcePages)
-
-    private val resourcePages = listOf("styles", "scripts", "images").map {
-        RendererSpecificResourcePage(it, emptyList(), RenderingStrategy.Copy("/dokka/$it"))
-    }
-}
-
-object StyleAndScriptsAppender : PageNodeTransformer {
-    override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
-        it.modified(
-            embeddedResources = it.embeddedResources + listOf(
-                "styles/style.css",
-                "scripts/navigationLoader.js"
-            )
-        )
-    }
-}
diff --git a/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
deleted file mode 100644
index 055df0b2..00000000
--- a/core/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
+++ /dev/null
@@ -1,143 +0,0 @@
-package org.jetbrains.dokka.transformers.psi
-
-import com.intellij.psi.*
-import com.intellij.psi.impl.source.PsiClassReferenceType
-import org.jetbrains.dokka.JavadocParser
-import org.jetbrains.dokka.links.Callable
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.links.JavaClassReference
-import org.jetbrains.dokka.links.withClass
-import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.model.Function
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.idea.caches.project.getPlatformModuleInfo
-import org.jetbrains.kotlin.platform.TargetPlatform
-
-object DefaultPsiToDocumentationTranslator : PsiToDocumentationTranslator {
-
-    override fun invoke(
-        moduleName: String,
-        psiFiles: List<PsiJavaFile>,
-        platformData: PlatformData,
-        context: DokkaContext
-    ): Module {
-        val docParser = DokkaPsiParser(platformData, context.logger)
-        return Module(moduleName,
-            psiFiles.map { psiFile ->
-                val dri = DRI(packageName = psiFile.packageName)
-                Package(
-                    dri,
-                    emptyList(),
-                    emptyList(),
-                    psiFile.classes.map { docParser.parseClass(it, dri) }
-                )
-            }
-        )
-    }
-
-    class DokkaPsiParser(
-        private val platformData: PlatformData,
-        logger: DokkaLogger
-    ) {
-
-        private val javadocParser: JavadocParser = JavadocParser(logger)
-
-        private fun getComment(psi: PsiNamedElement): List<PlatformInfo> {
-            val comment = javadocParser.parseDocumentation(psi)
-            return listOf(BasePlatformInfo(comment, listOf(platformData)))
-        }
-
-        private fun PsiModifierListOwner.getVisibility() = modifierList?.children?.toList()?.let { ml ->
-            when {
-                ml.any { it.text == PsiKeyword.PUBLIC } -> Visibilities.PUBLIC
-                ml.any { it.text == PsiKeyword.PROTECTED } -> Visibilities.PROTECTED
-                else -> Visibilities.PRIVATE
-            }
-        } ?: Visibilities.PRIVATE
-
-        fun parseClass(psi: PsiClass, parent: DRI): Class = with(psi) {
-            val kind = when {
-                isAnnotationType -> JavaClassKindTypes.ANNOTATION_CLASS
-                isInterface -> JavaClassKindTypes.INTERFACE
-                isEnum -> JavaClassKindTypes.ENUM_CLASS
-                else -> JavaClassKindTypes.CLASS
-            }
-            val dri = parent.withClass(name.toString())
-            /*superTypes.filter { !ignoreSupertype(it) }.forEach {
-            node.appendType(it, NodeKind.Supertype)
-            val superClass = it.resolve()
-            if (superClass != null) {
-                link(superClass, node, RefKind.Inheritor)
-            }
-        }*/
-            val inherited = emptyList<DRI>() //listOf(psi.superClass) + psi.interfaces // TODO DRIs of inherited
-            val actual = getComment(psi).map { ClassPlatformInfo(it, inherited) }
-
-            return Class(
-                dri = dri,
-                name = name.orEmpty(),
-                kind = kind,
-                constructors = constructors.map { parseFunction(it, dri, true) },
-                functions = methods.mapNotNull { if (!it.isConstructor) parseFunction(it, dri) else null },
-                properties = fields.mapNotNull { parseField(it, dri) },
-                classlikes = innerClasses.map { parseClass(it, dri) },
-                expected = null,
-                actual = actual,
-                extra = mutableSetOf(),
-                visibility = mapOf(platformData to psi.getVisibility())
-            )
-        }
-
-        private fun parseFunction(psi: PsiMethod, parent: DRI, isConstructor: Boolean = false): Function {
-            val dri = parent.copy(callable = Callable(
-                psi.name,
-                JavaClassReference(psi.containingClass?.name.orEmpty()),
-                psi.parameterList.parameters.map { parameter ->
-                    JavaClassReference(parameter.type.canonicalText)
-                }
-            )
-            )
-            return Function(
-                dri,
-                if (isConstructor) "<init>" else psi.name,
-                psi.returnType?.let { JavaTypeWrapper(type = it) },
-                isConstructor,
-                null,
-                psi.parameterList.parameters.mapIndexed { index, psiParameter ->
-                    Parameter(
-                        dri.copy(target = index + 1),
-                        psiParameter.name,
-                        JavaTypeWrapper(psiParameter.type),
-                        null,
-                        getComment(psi)
-                    )
-                },
-                null,
-                getComment(psi),
-                visibility = mapOf(platformData to psi.getVisibility())
-            )
-        }
-
-        private fun parseField(psi: PsiField, parent: DRI): Property {
-            val dri = parent.copy(
-                callable = Callable(
-                    psi.name,
-                    JavaClassReference(psi.containingClass?.name.orEmpty()),
-                    emptyList()
-                )
-            )
-            return Property(
-                dri,
-                psi.name,
-                null,
-                null,
-                getComment(psi),
-                accessors = emptyList(),
-                visibility = mapOf(platformData to psi.getVisibility())
-            )
-        }
-    }
-}
diff --git a/plugins/base/build.gradle.kts b/plugins/base/build.gradle.kts
index ba0b5753..b42d7e28 100644
--- a/plugins/base/build.gradle.kts
+++ b/plugins/base/build.gradle.kts
@@ -7,3 +7,7 @@ publishing {
     }
 }
 
+dependencies {
+    implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
+}
+
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index 34c0ffae..bafd30ff 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -4,13 +4,19 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.base.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentableMerger
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentablesToPageTranslator
+import org.jetbrains.dokka.base.transformers.psi.DefaultPsiToDocumentationTranslator
 import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.renderers.html.HtmlRenderer
 
 class DokkaBase: DokkaPlugin() {
     val descriptorToDocumentationTranslator by extending(isFallback = true) {
         CoreExtensions.descriptorToDocumentationTranslator providing ::DefaultDescriptorToDocumentationTranslator
     }
 
+    val psiToDocumentationTranslator by extending(isFallback = true) {
+        CoreExtensions.psiToDocumentationTranslator with DefaultPsiToDocumentationTranslator
+    }
+
     val documentableMerger by extending(isFallback = true) {
         CoreExtensions.documentableMerger with DefaultDocumentableMerger
     }
@@ -18,4 +24,8 @@ class DokkaBase: DokkaPlugin() {
     val documentablesToPageTranslator by extending(isFallback = true) {
         CoreExtensions.documentablesToPageTranslator with DefaultDocumentablesToPageTranslator
     }
+
+    val htmlRenderer by extending {
+        CoreExtensions.renderer providing ::HtmlRenderer
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
new file mode 100644
index 00000000..c6183cf3
--- /dev/null
+++ b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -0,0 +1,127 @@
+package org.jetbrains.dokka.base.renderers
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.renderers.OutputWriter
+import org.jetbrains.dokka.renderers.Renderer
+import org.jetbrains.dokka.resolvers.LocationProvider
+import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
+
+abstract class DefaultRenderer<T>(
+    protected val context: DokkaContext
+) : Renderer {
+
+    protected val outputWriter = context.single(CoreExtensions.outputWriter)
+
+    protected lateinit var locationProvider: LocationProvider
+        private set
+
+    protected open val preprocessors: Iterable<PageNodeTransformer> = emptyList()
+
+    abstract fun T.buildHeader(level: Int, content: T.() -> Unit)
+    abstract fun T.buildLink(address: String, content: T.() -> Unit)
+    abstract fun T.buildList(node: ContentList, pageContext: ContentPage)
+    abstract fun T.buildNewLine()
+    abstract fun T.buildResource(node: ContentEmbeddedResource, pageContext: ContentPage)
+    abstract fun T.buildTable(node: ContentTable, pageContext: ContentPage)
+    abstract fun T.buildText(textNode: ContentText)
+    abstract fun T.buildNavigation(page: PageNode)
+
+    abstract fun buildPage(page: ContentPage, content: (T, ContentPage) -> Unit): String
+    abstract fun buildError(node: ContentNode)
+
+    open fun T.buildGroup(node: ContentGroup, pageContext: ContentPage) {
+        node.children.forEach { it.build(this, pageContext) }
+    }
+
+    open fun T.buildLinkText(nodes: List<ContentNode>, pageContext: ContentPage) {
+        nodes.forEach { it.build(this, pageContext) }
+    }
+
+    open fun T.buildCode(code: List<ContentNode>, language: String, pageContext: ContentPage) {
+        code.forEach { it.build(this, pageContext) }
+    }
+
+    open fun T.buildHeader(node: ContentHeader, pageContext: ContentPage) {
+        buildHeader(node.level) { node.children.forEach { it.build(this, pageContext) } }
+    }
+
+    open fun ContentNode.build(builder: T, pageContext: ContentPage) =
+        builder.buildContentNode(this, pageContext)
+
+    open fun T.buildContentNode(node: ContentNode, pageContext: ContentPage) {
+        when (node) {
+            is ContentText -> buildText(node)
+            is ContentHeader -> buildHeader(node, pageContext)
+            is ContentCode -> buildCode(node.children, node.language, pageContext)
+            is ContentDRILink -> buildLink(
+                locationProvider.resolve(node.address, node.platforms.toList(), pageContext)
+            ) {
+                buildLinkText(node.children, pageContext)
+            }
+            is ContentResolvedLink -> buildLink(node.address) { buildLinkText(node.children, pageContext) }
+            is ContentEmbeddedResource -> buildResource(node, pageContext)
+            is ContentList -> buildList(node, pageContext)
+            is ContentTable -> buildTable(node, pageContext)
+            is ContentGroup -> buildGroup(node, pageContext)
+            else -> buildError(node)
+        }
+    }
+
+    open fun buildPageContent(context: T, page: ContentPage) {
+        context.buildNavigation(page)
+        page.content.build(context, page)
+    }
+
+    open fun renderPage(page: PageNode) {
+        val path by lazy { locationProvider.resolve(page, skipExtension = true) }
+        when (page) {
+            is ContentPage -> outputWriter.write(path, buildPage(page) { c, p -> buildPageContent(c, p) }, ".html")
+            is RendererSpecificPage -> when (val strategy = page.strategy) {
+                is RenderingStrategy.Copy -> outputWriter.writeResources(strategy.from, path)
+                is RenderingStrategy.Write -> outputWriter.write(path, strategy.text, "")
+                is RenderingStrategy.Callback -> outputWriter.write(path, strategy.instructions(this, page), ".html")
+                RenderingStrategy.DoNothing -> Unit
+            }
+            else -> throw AssertionError(
+                "Page ${page.name} cannot be rendered by renderer as it is not renderer specific nor contains content"
+            )
+        }
+    }
+
+    open fun renderPages(root: PageNode) {
+        renderPage(root)
+        root.children.forEach { renderPages(it) }
+    }
+
+    // reimplement this as preprocessor
+    open fun renderPackageList(root: ContentPage) =
+        getPackageNamesAndPlatforms(root)
+            .keys
+            .joinToString("\n")
+            .also { outputWriter.write("${root.name}/package-list", it, "") }
+
+    open fun getPackageNamesAndPlatforms(root: PageNode): Map<String, List<PlatformData>> =
+        root.children
+            .map(::getPackageNamesAndPlatforms)
+            .fold(emptyMap<String, List<PlatformData>>()) { e, acc -> acc + e } +
+                if (root is PackagePageNode) {
+                    mapOf(root.name to root.platforms())
+                } else {
+                    emptyMap()
+                }
+
+    override fun render(root: RootPageNode) {
+        val newRoot = preprocessors.fold(root) { acc, t -> t(acc) }
+
+        locationProvider =
+            context.single(CoreExtensions.locationProviderFactory).getLocationProvider(newRoot)
+
+        root.children<ModulePageNode>().forEach { renderPackageList(it) }
+
+        renderPages(newRoot)
+    }
+}
+
+fun ContentPage.platforms() = this.content.platforms.toList()
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
new file mode 100644
index 00000000..c9270681
--- /dev/null
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -0,0 +1,216 @@
+package org.jetbrains.dokka.renderers.html
+
+import kotlinx.html.*
+import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.base.renderers.DefaultRenderer
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.renderers.OutputWriter
+import java.io.File
+
+open class HtmlRenderer(
+    context: DokkaContext
+) : DefaultRenderer<FlowContent>(context) {
+
+    private val pageList = mutableListOf<String>()
+
+    override val preprocessors = listOf(
+        RootCreator,
+        SearchPageInstaller,
+        ResourceInstaller,
+        NavigationPageInstaller,
+        StyleAndScriptsAppender
+    )
+
+    override fun FlowContent.buildList(node: ContentList, pageContext: ContentPage) =
+        if (node.ordered) ol {
+            buildListItems(node.children, pageContext)
+        }
+        else ul {
+            buildListItems(node.children, pageContext)
+        }
+
+    open fun OL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
+        items.forEach {
+            if (it is ContentList)
+                buildList(it, pageContext)
+            else
+                li { it.build(this, pageContext) }
+        }
+    }
+
+    open fun UL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
+        items.forEach {
+            if (it is ContentList)
+                buildList(it, pageContext)
+            else
+                li { it.build(this, pageContext) }
+        }
+    }
+
+    override fun FlowContent.buildResource(
+        node: ContentEmbeddedResource,
+        pageContext: ContentPage
+    ) { // TODO: extension point there
+        val imageExtensions = setOf("png", "jpg", "jpeg", "gif", "bmp", "tif", "webp", "svg")
+        return if (File(node.address).extension.toLowerCase() in imageExtensions) {
+            //TODO: add imgAttrs parsing
+            val imgAttrs = node.extras.filterIsInstance<HTMLSimpleAttr>().joinAttr()
+            img(src = node.address, alt = node.altText)
+        } else {
+            println("Unrecognized resource type: $node")
+        }
+    }
+
+    override fun FlowContent.buildTable(node: ContentTable, pageContext: ContentPage) {
+        table {
+            thead {
+                node.header.forEach {
+                    tr {
+                        it.children.forEach {
+                            th {
+                                it.build(this@table, pageContext)
+                            }
+                        }
+                    }
+                }
+            }
+            tbody {
+                node.children.forEach {
+                    tr {
+                        it.children.forEach {
+                            td {
+                                it.build(this, pageContext)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    override fun FlowContent.buildHeader(level: Int, content: FlowContent.() -> Unit) {
+        when (level) {
+            1 -> h1(block = content)
+            2 -> h2(block = content)
+            3 -> h3(block = content)
+            4 -> h4(block = content)
+            5 -> h5(block = content)
+            else -> h6(block = content)
+        }
+    }
+
+    override fun FlowContent.buildNavigation(page: PageNode) =
+        locationProvider.ancestors(page).asReversed().forEach { node ->
+            text("/")
+            if (node.isNavigable) buildLink(node, page)
+            else text(node.name)
+        }
+
+    private fun FlowContent.buildLink(to: PageNode, from: PageNode) =
+        buildLink(locationProvider.resolve(to, from)) {
+            text(to.name)
+        }
+
+    fun FlowContent.buildLink(
+        to: DRI,
+        platforms: List<PlatformData>,
+        from: PageNode? = null,
+        block: FlowContent.() -> Unit
+    ) = buildLink(locationProvider.resolve(to, platforms, from), block)
+
+    override fun buildError(node: ContentNode) {
+        context.logger.error("Unknown ContentNode type: $node")
+    }
+
+    override fun FlowContent.buildNewLine() {
+        br()
+    }
+
+    override fun FlowContent.buildLink(address: String, content: FlowContent.() -> Unit) =
+        a(href = address, block = content)
+
+    override fun FlowContent.buildCode(code: List<ContentNode>, language: String, pageContext: ContentPage) {
+        buildNewLine()
+        code.forEach {
+            +((it as? ContentText)?.text ?: run { context.logger.error("Cannot cast $it as ContentText!"); "" })
+            buildNewLine()
+        }
+    }
+
+    override fun renderPage(page: PageNode) {
+        super.renderPage(page)
+        if (page is ContentPage) {
+            pageList.add(
+                """{ "name": "${page.name}", ${if (page is ClasslikePageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(
+                    page
+                )}" }"""
+            )
+        }
+    }
+
+    override fun FlowContent.buildText(textNode: ContentText) {
+        text(textNode.text)
+    }
+
+    override fun render(root: RootPageNode) {
+        super.render(root)
+        outputWriter.write("scripts/pages", "var pages = [\n${pageList.joinToString(",\n")}\n]", ".js")
+    }
+
+    private fun PageNode.root(path: String) = locationProvider.resolveRoot(this) + path
+
+    override fun buildPage(page: ContentPage, content: (FlowContent, ContentPage) -> Unit): String =
+        buildHtml(page, page.embeddedResources) { content(this, page) }
+
+    open fun buildHtml(page: PageNode, resources: List<String>, content: FlowContent.() -> Unit) =
+        createHTML().html {
+            head {
+                title(page.name)
+                with(resources) {
+                    filter { it.substringBefore('?').substringAfterLast('.') == "css" }
+                        .forEach { link(rel = LinkRel.stylesheet, href = page.root(it)) }
+                    filter { it.substringBefore('?').substringAfterLast('.') == "js" }
+                        .forEach { script(type = ScriptType.textJavaScript, src = page.root(it)) { async = true } }
+                }
+                script { unsafe { +"""var pathToRoot = "${locationProvider.resolveRoot(page)}";""" } }
+            }
+            body {
+                div {
+                    id = "navigation"
+                    div {
+                        id = "searchBar"
+                        form(action = page.root("-search.html"), method = FormMethod.get) {
+                            id = "searchForm"
+                            input(type = InputType.search, name = "query")
+                            input(type = InputType.submit) { value = "Search" }
+                        }
+                    }
+                    div {
+                        id = "sideMenu"
+                    }
+                }
+                div {
+                    id = "content"
+                    content()
+                }
+            }
+        }
+}
+
+fun List<HTMLMetadata>.joinAttr() = joinToString(" ") { it.key + "=" + it.value }
+
+private fun PageNode.pageKind() = when (this) {
+    is PackagePageNode -> "package"
+    is ClasslikePageNode -> "class"
+    is MemberPageNode -> when (this.documentable) {
+        is Function -> "function"
+        else -> "other"
+    }
+    else -> "other"
+}
+
+private val PageNode.isNavigable: Boolean
+    get() = this !is RendererSpecificPage || strategy != RenderingStrategy.DoNothing
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
new file mode 100644
index 00000000..4a2fb40d
--- /dev/null
+++ b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
@@ -0,0 +1,50 @@
+package org.jetbrains.dokka.renderers.html
+
+import kotlinx.html.*
+import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.pages.RendererSpecificPage
+import org.jetbrains.dokka.pages.RenderingStrategy
+
+class NavigationPage(val root: NavigationNode) : RendererSpecificPage {
+    override val name = "navigation"
+
+    override val children = emptyList<PageNode>()
+
+    override fun modified(name: String, children: List<PageNode>) = this
+
+    override val strategy = RenderingStrategy<HtmlRenderer> {
+        createHTML().visit(root, "nav-submenu", this)
+    }
+
+    private fun <R> TagConsumer<R>.visit(node: NavigationNode, navId: String, renderer: HtmlRenderer): R =
+        with(renderer) {
+            div("sideMenuPart") {
+                id = navId
+                div("overview") {
+                    buildLink(node.dri, node.platforms) { +node.name }
+                    if (node.children.isNotEmpty()) {
+                        span("navButton") {
+                            onClick = """document.getElementById("$navId").classList.toggle("hidden");"""
+                            span("navButtonContent")
+                        }
+                    }
+                }
+                node.children.withIndex().forEach { (n, p) -> visit(p, "$navId-$n", renderer) }
+            }
+        }
+}
+
+class NavigationNode(
+    val name: String,
+    val dri: DRI,
+    val platforms: List<PlatformData>,
+    val children: List<NavigationNode>
+)
+
+fun NavigationPage.transform(block: (NavigationNode) -> NavigationNode) = NavigationPage(root.transform(block))
+
+fun NavigationNode.transform(block: (NavigationNode) -> NavigationNode) =
+    run(block).let { NavigationNode(it.name, it.dri, it.platforms, it.children.map(block)) }
diff --git a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
new file mode 100644
index 00000000..09164d97
--- /dev/null
+++ b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -0,0 +1,68 @@
+package org.jetbrains.dokka.renderers.html
+
+import kotlinx.html.h1
+import kotlinx.html.id
+import kotlinx.html.table
+import kotlinx.html.tbody
+import org.jetbrains.dokka.base.renderers.platforms
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
+
+object RootCreator : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) =
+        RendererSpecificRootPage("", listOf(input), RenderingStrategy.DoNothing)
+}
+
+object SearchPageInstaller : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) = input.modified(children = input.children + searchPage)
+
+    private val searchPage = RendererSpecificResourcePage(
+        name = "Search",
+        children = emptyList(),
+        strategy = RenderingStrategy<HtmlRenderer> {
+            buildHtml(it, listOf("styles/style.css", "scripts/pages.js")) {
+                h1 {
+                    id = "searchTitle"
+                    text("Search results for ")
+                }
+                table {
+                    tbody {
+                        id = "searchTable"
+                    }
+                }
+            }
+        })
+}
+
+object NavigationPageInstaller : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) = input.modified(
+        children = input.children + NavigationPage(
+            input.children.filterIsInstance<ContentPage>().single().let(::visit)
+        )
+    )
+
+    private fun visit(page: ContentPage): NavigationNode = NavigationNode(
+        page.name,
+        page.dri.first(),
+        page.platforms(),
+        page.children.filterIsInstance<ContentPage>().map { visit(it) })
+}
+
+object ResourceInstaller : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) = input.modified(children = input.children + resourcePages)
+
+    private val resourcePages = listOf("styles", "scripts", "images").map {
+        RendererSpecificResourcePage(it, emptyList(), RenderingStrategy.Copy("/dokka/$it"))
+    }
+}
+
+object StyleAndScriptsAppender : PageNodeTransformer {
+    override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
+        it.modified(
+            embeddedResources = it.embeddedResources + listOf(
+                "styles/style.css",
+                "scripts/navigationLoader.js"
+            )
+        )
+    }
+}
diff --git a/plugins/base/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt b/plugins/base/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
new file mode 100644
index 00000000..b913ae88
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/psi/DefaultPsiToDocumentationTranslator.kt
@@ -0,0 +1,145 @@
+package org.jetbrains.dokka.base.transformers.psi
+
+import com.intellij.psi.*
+import org.jetbrains.dokka.JavadocParser
+import org.jetbrains.dokka.links.Callable
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.links.JavaClassReference
+import org.jetbrains.dokka.links.withClass
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.transformers.psi.PsiToDocumentationTranslator
+import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.kotlin.descriptors.Visibilities
+
+object DefaultPsiToDocumentationTranslator : PsiToDocumentationTranslator {
+
+    override fun invoke(
+        moduleName: String,
+        psiFiles: List<PsiJavaFile>,
+        platformData: PlatformData,
+        context: DokkaContext
+    ): Module {
+        val docParser =
+            DokkaPsiParser(
+                platformData,
+                context.logger
+            )
+        return Module(moduleName,
+            psiFiles.map { psiFile ->
+                val dri = DRI(packageName = psiFile.packageName)
+                Package(
+                    dri,
+                    emptyList(),
+                    emptyList(),
+                    psiFile.classes.map { docParser.parseClass(it, dri) }
+                )
+            }
+        )
+    }
+
+    class DokkaPsiParser(
+        private val platformData: PlatformData,
+        logger: DokkaLogger
+    ) {
+
+        private val javadocParser: JavadocParser = JavadocParser(logger)
+
+        private fun getComment(psi: PsiNamedElement): List<PlatformInfo> {
+            val comment = javadocParser.parseDocumentation(psi)
+            return listOf(BasePlatformInfo(comment, listOf(platformData)))
+        }
+
+        private fun PsiModifierListOwner.getVisibility() = modifierList?.children?.toList()?.let { ml ->
+            when {
+                ml.any { it.text == PsiKeyword.PUBLIC } -> Visibilities.PUBLIC
+                ml.any { it.text == PsiKeyword.PROTECTED } -> Visibilities.PROTECTED
+                else -> Visibilities.PRIVATE
+            }
+        } ?: Visibilities.PRIVATE
+
+        fun parseClass(psi: PsiClass, parent: DRI): Class = with(psi) {
+            val kind = when {
+                isAnnotationType -> JavaClassKindTypes.ANNOTATION_CLASS
+                isInterface -> JavaClassKindTypes.INTERFACE
+                isEnum -> JavaClassKindTypes.ENUM_CLASS
+                else -> JavaClassKindTypes.CLASS
+            }
+            val dri = parent.withClass(name.toString())
+            /*superTypes.filter { !ignoreSupertype(it) }.forEach {
+            node.appendType(it, NodeKind.Supertype)
+            val superClass = it.resolve()
+            if (superClass != null) {
+                link(superClass, node, RefKind.Inheritor)
+            }
+        }*/
+            val inherited = emptyList<DRI>() //listOf(psi.superClass) + psi.interfaces // TODO DRIs of inherited
+            val actual = getComment(psi).map { ClassPlatformInfo(it, inherited) }
+
+            return Class(
+                dri = dri,
+                name = name.orEmpty(),
+                kind = kind,
+                constructors = constructors.map { parseFunction(it, dri, true) },
+                functions = methods.mapNotNull { if (!it.isConstructor) parseFunction(it, dri) else null },
+                properties = fields.mapNotNull { parseField(it, dri) },
+                classlikes = innerClasses.map { parseClass(it, dri) },
+                expected = null,
+                actual = actual,
+                extra = mutableSetOf(),
+                visibility = mapOf(platformData to psi.getVisibility())
+            )
+        }
+
+        private fun parseFunction(psi: PsiMethod, parent: DRI, isConstructor: Boolean = false): Function {
+            val dri = parent.copy(callable = Callable(
+                psi.name,
+                JavaClassReference(psi.containingClass?.name.orEmpty()),
+                psi.parameterList.parameters.map { parameter ->
+                    JavaClassReference(parameter.type.canonicalText)
+                }
+            )
+            )
+            return Function(
+                dri,
+                if (isConstructor) "<init>" else psi.name,
+                psi.returnType?.let { JavaTypeWrapper(type = it) },
+                isConstructor,
+                null,
+                psi.parameterList.parameters.mapIndexed { index, psiParameter ->
+                    Parameter(
+                        dri.copy(target = index + 1),
+                        psiParameter.name,
+                        JavaTypeWrapper(psiParameter.type),
+                        null,
+                        getComment(psi)
+                    )
+                },
+                null,
+                getComment(psi),
+                visibility = mapOf(platformData to psi.getVisibility())
+            )
+        }
+
+        private fun parseField(psi: PsiField, parent: DRI): Property {
+            val dri = parent.copy(
+                callable = Callable(
+                    psi.name!!, // TODO: Investigate if this is indeed nullable
+                    JavaClassReference(psi.containingClass?.name.orEmpty()),
+                    emptyList()
+                )
+            )
+            return Property(
+                dri,
+                psi.name!!, // TODO: Investigate if this is indeed nullable
+                null,
+                null,
+                getComment(psi),
+                accessors = emptyList(),
+                visibility = mapOf(platformData to psi.getVisibility())
+            )
+        }
+    }
+}
-- 
cgit 


From 2bfb7733dfef8da0271a01a7275ea42ecb69d93a Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 17 Feb 2020 10:55:44 +0100
Subject: Cleans up page mergers and moves them to base plugin

---
 core/src/main/kotlin/CoreExtensions.kt             |  2 --
 .../main/kotlin/plugability/DefaultExtensions.kt   |  4 ---
 core/src/main/kotlin/plugability/DokkaContext.kt   |  3 ++
 core/src/main/kotlin/plugability/DokkaPlugin.kt    |  6 +++-
 .../pages/DefaultPageMergerStrategy.kt             | 11 -------
 .../transformers/pages/DefaultPageNodeMerger.kt    | 23 --------------
 .../transformers/pages/PageMergerStrategy.kt       |  9 ------
 .../pages/SameMethodNamePageMergerStrategy.kt      | 33 --------------------
 plugins/base/src/main/kotlin/DokkaBase.kt          | 22 +++++++++++++-
 .../pages/merger/FallbackPageMergerStrategy.kt     | 12 ++++++++
 .../pages/merger/PageMergerStrategy.kt             |  9 ++++++
 .../transformers/pages/merger/PageNodeMerger.kt    | 29 ++++++++++++++++++
 .../merger/SameMethodNamePageMergerStrategy.kt     | 35 ++++++++++++++++++++++
 .../test/kotlin/pageMerger/PageNodeMergerTest.kt   | 16 +++++-----
 14 files changed, 123 insertions(+), 91 deletions(-)
 delete mode 100644 core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
 delete mode 100644 core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
 delete mode 100644 core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt
 delete mode 100644 core/src/main/kotlin/transformers/pages/SameMethodNamePageMergerStrategy.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/pages/merger/FallbackPageMergerStrategy.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/pages/merger/PageMergerStrategy.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/pages/merger/PageNodeMerger.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/pages/merger/SameMethodNamePageMergerStrategy.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 2d705c1b..0f88b492 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -9,7 +9,6 @@ import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTra
 import org.jetbrains.dokka.transformers.documentation.DocumentableMerger
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeTransformer
 import org.jetbrains.dokka.transformers.documentation.DocumentablesToPageTranslator
-import org.jetbrains.dokka.transformers.pages.PageMergerStrategy
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 import org.jetbrains.dokka.transformers.psi.PsiToDocumentationTranslator
 import kotlin.reflect.KProperty
@@ -31,7 +30,6 @@ object CoreExtensions {
     val commentsToContentConverter by coreExtension<CommentsToContentConverter>()
     val locationProviderFactory by coreExtension<LocationProviderFactory>()
     val outputWriter by coreExtension<OutputWriter>()
-    val pageMergerStrategy by coreExtension<PageMergerStrategy>()
 
     private fun <T: Any> coreExtension() = object {
         operator fun provideDelegate(thisRef: CoreExtensions, property: KProperty<*>): Lazy<ExtensionPoint<T>> =
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 828d1bf1..1a367d30 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -5,8 +5,6 @@ import org.jetbrains.dokka.pages.DocTagToContentConverter
 import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.OutputWriter
 import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
-import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
-import org.jetbrains.dokka.transformers.pages.DefaultPageNodeMerger
 
 internal object DefaultExtensions {
 
@@ -18,10 +16,8 @@ internal object DefaultExtensions {
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
             CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
-            CoreExtensions.pageTransformer -> DefaultPageNodeMerger(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
             CoreExtensions.outputWriter ->  outputWriter.get(fullContext)
-            CoreExtensions.pageMergerStrategy -> DefaultPageMergerStrategy(fullContext.logger)
             else -> null
         }.let { listOfNotNull( it ) as List<T> }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index b4be5862..bcf6e1e0 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -43,6 +43,9 @@ interface DokkaContext {
     }
 }
 
+inline fun <reified T: DokkaPlugin> DokkaContext.plugin(): T = plugin(T::class)
+    ?: throw java.lang.IllegalStateException("Plugin ${T::class.qualifiedName} is not present in context.")
+
 interface DokkaContextConfiguration {
     fun addExtensionDependencies(extension: Extension<*>)
 }
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index cdc92ca5..c00b0af3 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -48,4 +48,8 @@ abstract class DokkaPlugin {
             .map { it.get(this) }
             .forEach { if (it.condition.invoke(configuration)) ctx.addExtensionDependencies(it) }
     }
-}
\ No newline at end of file
+}
+
+inline fun <reified P : DokkaPlugin, reified E : Any> P.query(extension: P.() -> ExtensionPoint<E>): List<E> =
+    context?.let { it[extension()] }
+        ?: throw IllegalStateException("Querying about plugins is only possible with dokka context initialised")
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
deleted file mode 100644
index 66562d8b..00000000
--- a/core/src/main/kotlin/transformers/pages/DefaultPageMergerStrategy.kt
+++ /dev/null
@@ -1,11 +0,0 @@
-package org.jetbrains.dokka.transformers.pages
-
-import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.utilities.DokkaLogger
-
-class DefaultPageMergerStrategy(val logger: DokkaLogger) : PageMergerStrategy {
-    override fun tryMerge(pages: List<PageNode>): List<PageNode> {
-        if (pages.size != 1) logger.warn("Expected 1 page, but got ${pages.size}")
-        return listOf(pages.first())
-    }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt b/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
deleted file mode 100644
index bdfe393e..00000000
--- a/core/src/main/kotlin/transformers/pages/DefaultPageNodeMerger.kt
+++ /dev/null
@@ -1,23 +0,0 @@
-package org.jetbrains.dokka.transformers.pages
-
-import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.pages.RootPageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-
-class DefaultPageNodeMerger(val context: DokkaContext) : PageNodeTransformer {
-    override fun invoke(input: RootPageNode): RootPageNode =
-        input.modified(children = input.children.map { it.mergeChildren() })
-
-    fun PageNode.mergeChildren(): PageNode = children.groupBy { it.name }
-        .map { (_, v) -> v.mergePageNodes() }
-        .let { pages -> modified(children = pages.map { it.first().mergeChildren() }) }
-
-    private fun List<PageNode>.mergePageNodes(): List<PageNode> =
-        context[CoreExtensions.pageMergerStrategy].fold(this) { pages, strategy -> tryMerge(strategy, pages) }
-
-    private fun tryMerge(strategy: PageMergerStrategy, pages: List<PageNode>) = if (pages.size > 1)
-        strategy.tryMerge(pages)
-    else
-        pages
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt
deleted file mode 100644
index 8eb526b3..00000000
--- a/core/src/main/kotlin/transformers/pages/PageMergerStrategy.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package org.jetbrains.dokka.transformers.pages
-
-import org.jetbrains.dokka.pages.PageNode
-
-interface PageMergerStrategy {
-
-    fun tryMerge(pages: List<PageNode>): List<PageNode>
-
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/pages/SameMethodNamePageMergerStrategy.kt b/core/src/main/kotlin/transformers/pages/SameMethodNamePageMergerStrategy.kt
deleted file mode 100644
index 3835506b..00000000
--- a/core/src/main/kotlin/transformers/pages/SameMethodNamePageMergerStrategy.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package org.jetbrains.dokka.transformers.pages
-
-import org.jetbrains.dokka.pages.*
-
-object SameMethodNamePageMergerStrategy : PageMergerStrategy {
-    override fun tryMerge(pages: List<PageNode>): List<PageNode> {
-        val name = pages.first().name
-        val members = pages.filterIsInstance<MemberPageNode>()
-        val others = pages.filterNot { it is MemberPageNode }
-
-        val resChildren = members.flatMap { it.children }.distinct()
-        val dri = members.flatMap { it.dri }.toSet()
-        val dci = DCI(
-            dri = dri,
-            kind = members.first().content.dci.kind
-        )
-
-        val merged = MemberPageNode(
-            dri = dri,
-            name = name,
-            children = resChildren,
-            content = asGroup(dci, members.map { it.content }),
-            documentable = null
-        )
-
-        return others + listOf(merged)
-    }
-
-    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
-        val n = nodes.first()
-        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
-    }
-}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index bafd30ff..ed23d77e 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -4,11 +4,17 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.base.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentableMerger
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentablesToPageTranslator
+import org.jetbrains.dokka.base.transformers.pages.merger.FallbackPageMergerStrategy
+import org.jetbrains.dokka.base.transformers.pages.merger.PageMergerStrategy
+import org.jetbrains.dokka.base.transformers.pages.merger.PageNodeMerger
+import org.jetbrains.dokka.base.transformers.pages.merger.SameMethodNamePageMergerStrategy
 import org.jetbrains.dokka.base.transformers.psi.DefaultPsiToDocumentationTranslator
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.renderers.html.HtmlRenderer
 
 class DokkaBase: DokkaPlugin() {
+    val pageMergerStrategy by extensionPoint<PageMergerStrategy>()
+
     val descriptorToDocumentationTranslator by extending(isFallback = true) {
         CoreExtensions.descriptorToDocumentationTranslator providing ::DefaultDescriptorToDocumentationTranslator
     }
@@ -25,7 +31,21 @@ class DokkaBase: DokkaPlugin() {
         CoreExtensions.documentablesToPageTranslator with DefaultDocumentablesToPageTranslator
     }
 
+    val pageMerger by extending {
+        CoreExtensions.pageTransformer providing { ctx -> PageNodeMerger(ctx[pageMergerStrategy]) }
+    }
+
+    val fallbackMerger by extending {
+        pageMergerStrategy providing { ctx -> FallbackPageMergerStrategy(ctx.logger) }
+    }
+
+    val sameMethodNameMerger by extending {
+        pageMergerStrategy with SameMethodNamePageMergerStrategy order {
+            before(fallbackMerger)
+        }
+    }
+
     val htmlRenderer by extending {
-        CoreExtensions.renderer providing ::HtmlRenderer
+        CoreExtensions.renderer providing ::HtmlRenderer applyIf { format == "html" }
     }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/pages/merger/FallbackPageMergerStrategy.kt b/plugins/base/src/main/kotlin/transformers/pages/merger/FallbackPageMergerStrategy.kt
new file mode 100644
index 00000000..df0c27ee
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/pages/merger/FallbackPageMergerStrategy.kt
@@ -0,0 +1,12 @@
+package org.jetbrains.dokka.base.transformers.pages.merger
+
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.utilities.DokkaLogger
+
+class FallbackPageMergerStrategy(private val logger: DokkaLogger) : PageMergerStrategy {
+    override fun tryMerge(pages: List<PageNode>, path: List<String>): List<PageNode> {
+        val renderedPath = path.joinToString(separator = "/")
+        if (pages.size != 1) logger.warn("For $renderedPath: expected 1 page, but got ${pages.size}")
+        return listOf(pages.first())
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/pages/merger/PageMergerStrategy.kt b/plugins/base/src/main/kotlin/transformers/pages/merger/PageMergerStrategy.kt
new file mode 100644
index 00000000..b73b17e0
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/pages/merger/PageMergerStrategy.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.dokka.base.transformers.pages.merger
+
+import org.jetbrains.dokka.pages.PageNode
+
+interface PageMergerStrategy {
+
+    fun tryMerge(pages: List<PageNode>, path: List<String>): List<PageNode>
+
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/pages/merger/PageNodeMerger.kt b/plugins/base/src/main/kotlin/transformers/pages/merger/PageNodeMerger.kt
new file mode 100644
index 00000000..5ecf8d9b
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/pages/merger/PageNodeMerger.kt
@@ -0,0 +1,29 @@
+package org.jetbrains.dokka.base.transformers.pages.merger
+
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
+
+class PageNodeMerger(private val strategies: Iterable<PageMergerStrategy>) : PageNodeTransformer {
+    override fun invoke(input: RootPageNode): RootPageNode =
+        input.modified(children = input.children.map { it.mergeChildren(emptyList()) })
+
+    private fun PageNode.mergeChildren(path: List<String>): PageNode = children.groupBy { it.name }
+        .map { (n, v) -> mergePageNodes(v, path + n) }
+        .let { pages ->
+            modified(children = pages.map { it.assertSingle(path) }.map { it.mergeChildren(path + it.name) })
+        }
+
+    private fun mergePageNodes(pages: List<PageNode>, path: List<String>): List<PageNode> =
+        strategies.fold(pages) { acc, strategy -> tryMerge(strategy, acc, path) }
+
+    private fun tryMerge(strategy: PageMergerStrategy, pages: List<PageNode>, path: List<String>) =
+        if (pages.size > 1) strategy.tryMerge(pages, path) else pages
+}
+
+private fun <T> Iterable<T>.assertSingle(path: List<String>): T = try {
+        single()
+    } catch (e: Exception) {
+        val renderedPath = path.joinToString(separator = "/")
+        throw IllegalStateException("Page merger is missconfigured. Error for $renderedPath: ${e.message}")
+    }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/pages/merger/SameMethodNamePageMergerStrategy.kt b/plugins/base/src/main/kotlin/transformers/pages/merger/SameMethodNamePageMergerStrategy.kt
new file mode 100644
index 00000000..fef55dd2
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/pages/merger/SameMethodNamePageMergerStrategy.kt
@@ -0,0 +1,35 @@
+package org.jetbrains.dokka.base.transformers.pages.merger
+
+import org.jetbrains.dokka.pages.*
+
+object SameMethodNamePageMergerStrategy : PageMergerStrategy {
+    override fun tryMerge(pages: List<PageNode>, path: List<String>): List<PageNode> {
+        val name = pages.first().name
+        val members = pages.filterIsInstance<MemberPageNode>()
+        val others = pages.filterNot { it is MemberPageNode }
+
+        val resChildren = members.flatMap { it.children }.distinct()
+        val dri = members.flatMap { it.dri }.toSet()
+        val dci = DCI(
+            dri = dri,
+            kind = members.first().content.dci.kind
+        )
+
+        val merged = MemberPageNode(
+            dri = dri,
+            name = name,
+            children = resChildren,
+            content = asGroup(
+                dci,
+                members.map { it.content }),
+            documentable = null
+        )
+
+        return others + listOf(merged)
+    }
+
+    fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup {
+        val n = nodes.first()
+        return ContentGroup(nodes, dci, n.platforms, n.style, n.extras)
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
index 88e57ddb..c6076d54 100644
--- a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
+++ b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
@@ -4,15 +4,15 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.pages.ContentPage
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.transformers.pages.DefaultPageMergerStrategy
-import org.jetbrains.dokka.transformers.pages.SameMethodNamePageMergerStrategy
+import org.jetbrains.dokka.base.transformers.pages.merger.SameMethodNamePageMergerStrategy
 import org.jetbrains.dokka.utilities.DokkaLogger
+import org.junit.Ignore
 import org.junit.Test
 import testApi.testRunner.AbstractCoreTest
 
 class PageNodeMergerTest : AbstractCoreTest() {
 
-    object SameNameStrategy : DokkaPlugin() {
+    /* object SameNameStrategy : DokkaPlugin() {
         val strategy by extending { CoreExtensions.pageMergerStrategy with SameMethodNamePageMergerStrategy }
     }
 
@@ -36,6 +36,7 @@ class PageNodeMergerTest : AbstractCoreTest() {
 
         override fun report() = TODO()
     }
+     */
 
     @Test
     fun sameNameStrategyTest() {
@@ -61,8 +62,8 @@ class PageNodeMergerTest : AbstractCoreTest() {
             |   fun test(str: String): String = str
             |}
         """.trimMargin(),
-            configuration,
-            pluginOverrides = listOf(SameNameStrategy)
+            configuration/*,
+            pluginOverrides = listOf(SameNameStrategy)*/
         ) {
             pagesTransformationStage = {
                 val allChildren = it.childrenRec().filterIsInstance<ContentPage>()
@@ -78,6 +79,7 @@ class PageNodeMergerTest : AbstractCoreTest() {
         }
     }
 
+    @Ignore("TODO: reenable when we have infrastructure for turning off extensions")
     @Test
     fun defaultStrategyTest() {
         val strList: MutableList<String> = mutableListOf()
@@ -103,8 +105,8 @@ class PageNodeMergerTest : AbstractCoreTest() {
             |   fun test(str: String): String = str
             |}
         """.trimMargin(),
-            configuration,
-            pluginOverrides = listOf(DefaultStrategy(strList))
+            configuration/*,
+            pluginOverrides = listOf(DefaultStrategy(strList)) */
         ) {
             pagesTransformationStage = { root ->
                 val allChildren = root.childrenRec().filterIsInstance<ContentPage>()
-- 
cgit 


From ba769f0695aaa9719b62ca32028fd3d24442f5ec Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 17 Feb 2020 11:27:37 +0100
Subject: Moves comments to content conversion to base plugin

---
 core/src/main/kotlin/CoreExtensions.kt             |   2 -
 core/src/main/kotlin/DokkaGenerator.kt             |   2 +-
 .../kotlin/pages/CommentsToContentConverter.kt     |  13 --
 .../main/kotlin/pages/DocTagToContentConverter.kt  |  97 ---------------
 .../main/kotlin/plugability/DefaultExtensions.kt   |   5 +-
 core/src/main/kotlin/plugability/DokkaPlugin.kt    |  12 +-
 .../documentation/DocumentablesToPageTranslator.kt |   2 +-
 plugins/base/src/main/kotlin/DokkaBase.kt          |  13 +-
 .../DefaultDocumentablesToPageTranslator.kt        |  13 +-
 .../documentables/PageContentBuilder.kt            |   1 +
 .../pages/comments/CommentsToContentConverter.kt   |  14 +++
 .../pages/comments/DocTagToContentConverter.kt     | 132 +++++++++++++++++++++
 .../main/kotlin/KotlinAsJavaPageContentBuilder.kt  |   1 +
 .../src/main/kotlin/KotlinAsJavaPlugin.kt          |  16 ++-
 14 files changed, 189 insertions(+), 134 deletions(-)
 delete mode 100644 core/src/main/kotlin/pages/CommentsToContentConverter.kt
 delete mode 100644 core/src/main/kotlin/pages/DocTagToContentConverter.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
 create mode 100644 plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 0f88b492..859e850e 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.pages.CommentsToContentConverter
 import org.jetbrains.dokka.plugability.ExtensionPoint
 import org.jetbrains.dokka.renderers.Renderer
 import org.jetbrains.dokka.renderers.OutputWriter
@@ -27,7 +26,6 @@ object CoreExtensions {
     val pageTransformer by coreExtension<PageNodeTransformer>()
     val renderer by coreExtension<Renderer>()
 
-    val commentsToContentConverter by coreExtension<CommentsToContentConverter>()
     val locationProviderFactory by coreExtension<LocationProviderFactory>()
     val outputWriter by coreExtension<OutputWriter>()
 
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 1ad93f4f..8897e68d 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -88,7 +88,7 @@ class DokkaGenerator(
     fun createPages(
         transformedDocumentation: Module,
         context: DokkaContext
-    ) = context.single(CoreExtensions.documentablesToPageTranslator).invoke(transformedDocumentation, context)
+    ) = context.single(CoreExtensions.documentablesToPageTranslator).invoke(transformedDocumentation)
 
     fun transformPages(
         pages: RootPageNode,
diff --git a/core/src/main/kotlin/pages/CommentsToContentConverter.kt b/core/src/main/kotlin/pages/CommentsToContentConverter.kt
deleted file mode 100644
index 78c7ff4c..00000000
--- a/core/src/main/kotlin/pages/CommentsToContentConverter.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.jetbrains.dokka.pages
-
-import org.jetbrains.dokka.model.doc.DocTag
-
-interface CommentsToContentConverter {
-    fun buildContent(
-        docTag: DocTag,
-        dci: DCI,
-        platforms: Set<PlatformData>,
-        styles: Set<Style> = emptySet(),
-        extras: Set<Extra> = emptySet()
-    ): List<ContentNode>
-}
diff --git a/core/src/main/kotlin/pages/DocTagToContentConverter.kt b/core/src/main/kotlin/pages/DocTagToContentConverter.kt
deleted file mode 100644
index 08a579a8..00000000
--- a/core/src/main/kotlin/pages/DocTagToContentConverter.kt
+++ /dev/null
@@ -1,97 +0,0 @@
-package org.jetbrains.dokka.pages
-
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.plugability.DokkaContext
-
-class DocTagToContentConverter(
-    private val context: DokkaContext
-) : CommentsToContentConverter {
-    override fun buildContent(
-        docTag: DocTag,
-        dci: DCI,
-        platforms: Set<PlatformData>,
-        styles: Set<Style>,
-        extras: Set<Extra>
-
-    ): List<ContentNode> {
-
-        fun buildChildren(docTag: DocTag, newStyles: Set<Style> = emptySet(), newExtras: Set<Extra> = emptySet()) =
-            docTag.children.flatMap {
-                buildContent(it, dci, platforms, styles + newStyles, extras + newExtras)
-            }
-
-        fun buildHeader(level: Int) =
-            listOf(ContentHeader(buildChildren(docTag), level, dci, platforms, styles, extras))
-
-        fun buildList(ordered: Boolean) =
-            listOf(ContentList(buildChildren(docTag), ordered, dci, platforms, styles, extras))
-
-        return when (docTag) {
-            is H1 -> buildHeader(1)
-            is H2 -> buildHeader(2)
-            is H3 -> buildHeader(3)
-            is H4 -> buildHeader(4)
-            is H5 -> buildHeader(5)
-            is H6 -> buildHeader(6)
-            is Ul -> buildList(false)
-            is Ol -> buildList(true)
-            is Li -> buildChildren(docTag)
-            is B -> buildChildren(docTag, setOf(TextStyle.Strong))
-            is I -> buildChildren(docTag, setOf(TextStyle.Italic))
-            is P -> buildChildren(docTag, newStyles = setOf(TextStyle.Paragraph))
-            is A -> listOf(
-                ContentResolvedLink(
-                    buildChildren(docTag),
-                    docTag.params.get("href")!!,
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            is DocumentationLink -> listOf(
-                ContentDRILink(
-                    buildChildren(docTag),
-                    docTag.dri,
-                    DCI(setOf(docTag.dri), ContentKind.Symbol),
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            is BlockQuote -> listOf(
-                ContentCode(
-                    buildChildren(docTag),
-                    "",
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            is Code -> listOf(
-                ContentCode(
-                    buildChildren(docTag),
-                    "",
-                    dci,
-                    platforms,
-                    styles,
-                    extras
-                )
-            )
-            is Img -> listOf(
-                ContentEmbeddedResource(
-                    address = docTag.params.get("href")!!,
-                    altText = docTag.params.get("alt"),
-                    dci = dci,
-                    platforms = platforms,
-                    style = styles,
-                    extras = extras
-                )
-            )
-            is HorizontalRule -> listOf(ContentText("", dci, platforms, setOf()))
-            is Text -> listOf(ContentText(docTag.body, dci, platforms, styles, extras))
-            else -> buildChildren(docTag)
-        }
-    }
-}
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 1a367d30..242eb6b8 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -1,23 +1,20 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.pages.DocTagToContentConverter
 import org.jetbrains.dokka.renderers.FileWriter
 import org.jetbrains.dokka.renderers.OutputWriter
 import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
 
 internal object DefaultExtensions {
 
-    private val converter: LazyEvaluated<DocTagToContentConverter> = LazyEvaluated.fromRecipe { DocTagToContentConverter(it) }
     private val providerFactory: LazyEvaluated<DefaultLocationProviderFactory> = LazyEvaluated.fromRecipe { DefaultLocationProviderFactory(it) }
     private val outputWriter: LazyEvaluated<OutputWriter> = LazyEvaluated.fromRecipe { FileWriter(it) }
 
     @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
-            CoreExtensions.commentsToContentConverter -> converter.get(fullContext)
             CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
-            CoreExtensions.outputWriter ->  outputWriter.get(fullContext)
+            CoreExtensions.outputWriter -> outputWriter.get(fullContext)
             else -> null
         }.let { listOfNotNull( it ) as List<T> }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index c00b0af3..d8fb7892 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -13,8 +13,7 @@ abstract class DokkaPlugin {
     @PublishedApi
     internal var context: DokkaContext? = null
 
-    protected inline fun <reified T : DokkaPlugin> plugin(): T = context?.plugin(T::class)
-        ?: throw IllegalStateException("Querying about plugins is only possible with dokka context initialised")
+    protected inline fun <reified T : DokkaPlugin> plugin(): T = context?.plugin(T::class) ?: throwIllegalQuery()
 
     protected fun <T : Any> extensionPoint() =
         object : ReadOnlyProperty<DokkaPlugin, ExtensionPoint<T>> {
@@ -51,5 +50,10 @@ abstract class DokkaPlugin {
 }
 
 inline fun <reified P : DokkaPlugin, reified E : Any> P.query(extension: P.() -> ExtensionPoint<E>): List<E> =
-    context?.let { it[extension()] }
-        ?: throw IllegalStateException("Querying about plugins is only possible with dokka context initialised")
\ No newline at end of file
+    context?.let { it[extension()] } ?: throwIllegalQuery()
+
+inline fun <reified P : DokkaPlugin, reified E : Any> P.querySingle(extension: P.() -> ExtensionPoint<E>): E =
+    context?.single(extension()) ?: throwIllegalQuery()
+
+fun throwIllegalQuery(): Nothing =
+    throw IllegalStateException("Querying about plugins is only possible with dokka context initialised")
diff --git a/core/src/main/kotlin/transformers/documentation/DocumentablesToPageTranslator.kt b/core/src/main/kotlin/transformers/documentation/DocumentablesToPageTranslator.kt
index fa74d216..19698fa0 100644
--- a/core/src/main/kotlin/transformers/documentation/DocumentablesToPageTranslator.kt
+++ b/core/src/main/kotlin/transformers/documentation/DocumentablesToPageTranslator.kt
@@ -5,5 +5,5 @@ import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface DocumentablesToPageTranslator {
-    operator fun invoke(module: Module, context: DokkaContext): ModulePageNode
+    operator fun invoke(module: Module): ModulePageNode
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index ed23d77e..9b6e9b1a 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -4,6 +4,8 @@ import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.base.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentableMerger
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentablesToPageTranslator
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
+import org.jetbrains.dokka.base.transformers.pages.comments.DocTagToContentConverter
 import org.jetbrains.dokka.base.transformers.pages.merger.FallbackPageMergerStrategy
 import org.jetbrains.dokka.base.transformers.pages.merger.PageMergerStrategy
 import org.jetbrains.dokka.base.transformers.pages.merger.PageNodeMerger
@@ -12,8 +14,9 @@ import org.jetbrains.dokka.base.transformers.psi.DefaultPsiToDocumentationTransl
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.renderers.html.HtmlRenderer
 
-class DokkaBase: DokkaPlugin() {
+class DokkaBase : DokkaPlugin() {
     val pageMergerStrategy by extensionPoint<PageMergerStrategy>()
+    val commentsToContentConverter by extensionPoint<CommentsToContentConverter>()
 
     val descriptorToDocumentationTranslator by extending(isFallback = true) {
         CoreExtensions.descriptorToDocumentationTranslator providing ::DefaultDescriptorToDocumentationTranslator
@@ -28,7 +31,13 @@ class DokkaBase: DokkaPlugin() {
     }
 
     val documentablesToPageTranslator by extending(isFallback = true) {
-        CoreExtensions.documentablesToPageTranslator with DefaultDocumentablesToPageTranslator
+        CoreExtensions.documentablesToPageTranslator providing { ctx ->
+            DefaultDocumentablesToPageTranslator(ctx.single(commentsToContentConverter), ctx.logger)
+        }
+    }
+
+    val docTagToContentConverter by extending(isFallback = true) {
+        commentsToContentConverter with DocTagToContentConverter
     }
 
     val pageMerger by extending {
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt
index 90f8e2d7..d28791ab 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentablesToPageTranslator.kt
@@ -1,21 +1,26 @@
 package org.jetbrains.dokka.base.transformers.documentables
 
 import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.pages.ModulePageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.DocumentablesToPageTranslator
+import org.jetbrains.dokka.utilities.DokkaLogger
 
 
-object DefaultDocumentablesToPageTranslator : DocumentablesToPageTranslator {
-    override fun invoke(module: Module, context: DokkaContext): ModulePageNode =
+class DefaultDocumentablesToPageTranslator(
+    private val commentsToContentConverter: CommentsToContentConverter,
+    private val logger: DokkaLogger
+) : DocumentablesToPageTranslator {
+    override fun invoke(module: Module): ModulePageNode =
         DefaultPageBuilder { node, kind, operation ->
             DefaultPageContentBuilder.group(
                 setOf(node.dri),
                 node.platformData,
                 kind,
-                context.single(CoreExtensions.commentsToContentConverter),
-                context.logger,
+                commentsToContentConverter,
+                logger,
                 operation
             )
         }.pageForModule(module)
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt
index 809b97a0..6ce883b1 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/PageContentBuilder.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.transformers.documentables
 
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.model.Function
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
new file mode 100644
index 00000000..4d2f14a5
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.dokka.base.transformers.pages.comments
+
+import org.jetbrains.dokka.model.doc.DocTag
+import org.jetbrains.dokka.pages.*
+
+interface CommentsToContentConverter {
+    fun buildContent(
+        docTag: DocTag,
+        dci: DCI,
+        platforms: Set<PlatformData>,
+        styles: Set<Style> = emptySet(),
+        extras: Set<Extra> = emptySet()
+    ): List<ContentNode>
+}
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
new file mode 100644
index 00000000..70792534
--- /dev/null
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
@@ -0,0 +1,132 @@
+package org.jetbrains.dokka.base.transformers.pages.comments
+
+import org.jetbrains.dokka.model.doc.*
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
+
+object DocTagToContentConverter : CommentsToContentConverter {
+    override fun buildContent(
+        docTag: DocTag,
+        dci: DCI,
+        platforms: Set<PlatformData>,
+        styles: Set<Style>,
+        extras: Set<Extra>
+
+    ): List<ContentNode> {
+
+        fun buildChildren(docTag: DocTag, newStyles: Set<Style> = emptySet(), newExtras: Set<Extra> = emptySet()) =
+            docTag.children.flatMap {
+                buildContent(it, dci, platforms, styles + newStyles, extras + newExtras)
+            }
+
+        fun buildHeader(level: Int) =
+            listOf(
+                ContentHeader(
+                    buildChildren(docTag),
+                    level,
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+
+        fun buildList(ordered: Boolean) =
+            listOf(
+                ContentList(
+                    buildChildren(docTag),
+                    ordered,
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+
+        return when (docTag) {
+            is H1 -> buildHeader(1)
+            is H2 -> buildHeader(2)
+            is H3 -> buildHeader(3)
+            is H4 -> buildHeader(4)
+            is H5 -> buildHeader(5)
+            is H6 -> buildHeader(6)
+            is Ul -> buildList(false)
+            is Ol -> buildList(true)
+            is Li -> buildChildren(docTag)
+            is B -> buildChildren(docTag, setOf(TextStyle.Strong))
+            is I -> buildChildren(docTag, setOf(TextStyle.Italic))
+            is P -> buildChildren(docTag, newStyles = setOf(TextStyle.Paragraph))
+            is A -> listOf(
+                ContentResolvedLink(
+                    buildChildren(docTag),
+                    docTag.params.get("href")!!,
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is DocumentationLink -> listOf(
+                ContentDRILink(
+                    buildChildren(docTag),
+                    docTag.dri,
+                    DCI(
+                        setOf(docTag.dri),
+                        ContentKind.Symbol
+                    ),
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is BlockQuote -> listOf(
+                ContentCode(
+                    buildChildren(docTag),
+                    "",
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is Code -> listOf(
+                ContentCode(
+                    buildChildren(docTag),
+                    "",
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            is Img -> listOf(
+                ContentEmbeddedResource(
+                    address = docTag.params["href"]!!,
+                    altText = docTag.params["alt"],
+                    dci = dci,
+                    platforms = platforms,
+                    style = styles,
+                    extras = extras
+                )
+            )
+            is HorizontalRule -> listOf(
+                ContentText(
+                    "",
+                    dci,
+                    platforms,
+                    setOf()
+                )
+            )
+            is Text -> listOf(
+                ContentText(
+                    docTag.body,
+                    dci,
+                    platforms,
+                    styles,
+                    extras
+                )
+            )
+            else -> buildChildren(docTag)
+        }
+    }
+}
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
index 02e6ff82..87649a83 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPageContentBuilder.kt
@@ -3,6 +3,7 @@ package org.jetbrains.dokka.kotlinAsJava
 import org.jetbrains.dokka.base.transformers.documentables.DefaultPageContentBuilder
 import org.jetbrains.dokka.base.transformers.documentables.PageContentBuilderFunction
 import org.jetbrains.dokka.base.transformers.documentables.type
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.model.JavaTypeWrapper
diff --git a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
index f8a25aca..f9389ebd 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/KotlinAsJavaPlugin.kt
@@ -2,12 +2,14 @@ package  org.jetbrains.dokka.kotlinAsJava
 
 
 import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Module
 import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.plugability.*
 import org.jetbrains.dokka.transformers.documentation.DocumentablesToPageTranslator
+import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 
 class KotlinAsJavaPlugin : DokkaPlugin() {
@@ -15,7 +17,7 @@ class KotlinAsJavaPlugin : DokkaPlugin() {
         CoreExtensions.descriptorToDocumentationTranslator providing ::KotlinAsJavaDescriptorToDocumentationTranslator
     }
     val kotlinAsJavaDocumentableToPageTranslator by extending {
-        CoreExtensions.documentablesToPageTranslator with KotlinAsJavaDocumentationToPageTranslator
+        CoreExtensions.documentablesToPageTranslator providing ::KotlinAsJavaDocumentationToPageTranslator
     }
 }
 
@@ -26,14 +28,16 @@ object DescriptorCache {
     operator fun get(dri: DRI): DeclarationDescriptor? = cache[dri]
 }
 
-object KotlinAsJavaDocumentationToPageTranslator : DocumentablesToPageTranslator {
-    override fun invoke(module: Module, context: DokkaContext): ModulePageNode =
+class KotlinAsJavaDocumentationToPageTranslator(
+    private val context: DokkaContext
+) : DocumentablesToPageTranslator {
+    override fun invoke(module: Module): ModulePageNode =
         KotlinAsJavaPageBuilder { node, kind, operation ->
             KotlinAsJavaPageContentBuilder.group(
                 setOf(node.dri),
                 node.platformData,
                 kind,
-                context.single(CoreExtensions.commentsToContentConverter),
+                context.plugin<DokkaBase>().querySingle { commentsToContentConverter },
                 context.logger,
                 operation
             )
-- 
cgit 


From a89d9a8c87cbe81bdba25b660d1b1fda1d0ce8ec Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 17 Feb 2020 12:35:15 +0100
Subject: Moves location providers and output writers to base plugin

---
 core/src/main/kotlin/CoreExtensions.kt             |   5 -
 .../main/kotlin/plugability/DefaultExtensions.kt   |   7 --
 core/src/main/kotlin/renderers/FileWriter.kt       |  78 -------------
 core/src/main/kotlin/renderers/OutputWriter.kt     |   7 --
 .../kotlin/resolvers/DefaultLocationProvider.kt    | 121 ---------------------
 .../kotlin/resolvers/ExternalLocationProvider.kt   |  99 -----------------
 core/src/main/kotlin/resolvers/LocationProvider.kt |  13 ---
 .../kotlin/resolvers/LocationProviderFactory.kt    |  14 ---
 plugins/base/src/main/kotlin/DokkaBase.kt          |  16 ++-
 .../src/main/kotlin/renderers/DefaultRenderer.kt   |  11 +-
 .../base/src/main/kotlin/renderers/FileWriter.kt   |  79 ++++++++++++++
 .../base/src/main/kotlin/renderers/OutputWriter.kt |   7 ++
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |   3 +-
 .../main/kotlin/renderers/html/NavigationPage.kt   |   2 +-
 .../kotlin/renderers/html/htmlPreprocessors.kt     |   2 +-
 .../kotlin/resolvers/DefaultLocationProvider.kt    | 116 ++++++++++++++++++++
 .../resolvers/DefaultLocationProviderFactory.kt    |   9 ++
 .../kotlin/resolvers/ExternalLocationProvider.kt   |  99 +++++++++++++++++
 .../src/main/kotlin/resolvers/LocationProvider.kt  |  19 ++++
 19 files changed, 353 insertions(+), 354 deletions(-)
 delete mode 100644 core/src/main/kotlin/renderers/FileWriter.kt
 delete mode 100644 core/src/main/kotlin/renderers/OutputWriter.kt
 delete mode 100644 core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
 delete mode 100644 core/src/main/kotlin/resolvers/ExternalLocationProvider.kt
 delete mode 100644 core/src/main/kotlin/resolvers/LocationProvider.kt
 delete mode 100644 core/src/main/kotlin/resolvers/LocationProviderFactory.kt
 create mode 100644 plugins/base/src/main/kotlin/renderers/FileWriter.kt
 create mode 100644 plugins/base/src/main/kotlin/renderers/OutputWriter.kt
 create mode 100644 plugins/base/src/main/kotlin/resolvers/DefaultLocationProvider.kt
 create mode 100644 plugins/base/src/main/kotlin/resolvers/DefaultLocationProviderFactory.kt
 create mode 100644 plugins/base/src/main/kotlin/resolvers/ExternalLocationProvider.kt
 create mode 100644 plugins/base/src/main/kotlin/resolvers/LocationProvider.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index 859e850e..c8314f4d 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -2,8 +2,6 @@ package org.jetbrains.dokka
 
 import org.jetbrains.dokka.plugability.ExtensionPoint
 import org.jetbrains.dokka.renderers.Renderer
-import org.jetbrains.dokka.renderers.OutputWriter
-import org.jetbrains.dokka.resolvers.LocationProviderFactory
 import org.jetbrains.dokka.transformers.descriptors.DescriptorToDocumentationTranslator
 import org.jetbrains.dokka.transformers.documentation.DocumentableMerger
 import org.jetbrains.dokka.transformers.documentation.DocumentationNodeTransformer
@@ -26,9 +24,6 @@ object CoreExtensions {
     val pageTransformer by coreExtension<PageNodeTransformer>()
     val renderer by coreExtension<Renderer>()
 
-    val locationProviderFactory by coreExtension<LocationProviderFactory>()
-    val outputWriter by coreExtension<OutputWriter>()
-
     private fun <T: Any> coreExtension() = object {
         operator fun provideDelegate(thisRef: CoreExtensions, property: KProperty<*>): Lazy<ExtensionPoint<T>> =
             lazy { ExtensionPoint<T>(thisRef::class.qualifiedName!!, property.name) }
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
index 242eb6b8..798e0f1a 100644
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ b/core/src/main/kotlin/plugability/DefaultExtensions.kt
@@ -1,20 +1,13 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.renderers.FileWriter
-import org.jetbrains.dokka.renderers.OutputWriter
-import org.jetbrains.dokka.resolvers.DefaultLocationProviderFactory
 
 internal object DefaultExtensions {
 
-    private val providerFactory: LazyEvaluated<DefaultLocationProviderFactory> = LazyEvaluated.fromRecipe { DefaultLocationProviderFactory(it) }
-    private val outputWriter: LazyEvaluated<OutputWriter> = LazyEvaluated.fromRecipe { FileWriter(it) }
 
     @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
     internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
         when (point) {
-            CoreExtensions.locationProviderFactory -> providerFactory.get(fullContext)
-            CoreExtensions.outputWriter -> outputWriter.get(fullContext)
             else -> null
         }.let { listOfNotNull( it ) as List<T> }
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/FileWriter.kt b/core/src/main/kotlin/renderers/FileWriter.kt
deleted file mode 100644
index 727a8d21..00000000
--- a/core/src/main/kotlin/renderers/FileWriter.kt
+++ /dev/null
@@ -1,78 +0,0 @@
-package org.jetbrains.dokka.renderers
-
-import org.jetbrains.dokka.plugability.DokkaContext
-import java.io.File
-import java.io.IOException
-import java.net.URI
-import java.nio.file.*
-
-class FileWriter(val context: DokkaContext): OutputWriter {
-    private val createdFiles: MutableSet<String> = mutableSetOf()
-    private val jarUriPrefix = "jar:file:"
-    private val root = context.configuration.outputDir
-
-    override fun write(path: String, text: String, ext: String) {
-        if (createdFiles.contains(path)) {
-            context.logger.error("An attempt to write ${root}/$path several times!")
-            return
-        }
-        createdFiles.add(path)
-
-        try {
-            val dir = Paths.get(root, path.dropLastWhile { it != '/' }).toFile()
-            dir.mkdirsOrFail()
-            Files.write(Paths.get(root, "$path$ext"), text.lines())
-        } catch (e: Throwable) {
-            context.logger.error("Failed to write $this. ${e.message}")
-            e.printStackTrace()
-        }
-    }
-
-    override fun writeResources(pathFrom: String, pathTo: String) =
-        if (javaClass.getResource(pathFrom).toURI().toString().startsWith(jarUriPrefix)) {
-            copyFromJar(pathFrom, pathTo)
-        } else {
-            copyFromDirectory(pathFrom, pathTo)
-        }
-
-
-    private fun copyFromDirectory(pathFrom: String, pathTo: String) {
-        val dest = Paths.get(root, pathTo).toFile()
-        val uri = javaClass.getResource(pathFrom).toURI()
-        File(uri).copyRecursively(dest, true)
-    }
-
-    private fun copyFromJar(pathFrom: String, pathTo: String) {
-        val rebase = fun(path: String) =
-            "$pathTo/${path.removePrefix(pathFrom)}"
-        val dest = Paths.get(root, pathTo).toFile()
-        dest.mkdirsOrFail()
-        val uri = javaClass.getResource(pathFrom).toURI()
-        val fs = getFileSystemForURI(uri)
-        val path = fs.getPath(pathFrom)
-        for (file in Files.walk(path).iterator()) {
-            if (Files.isDirectory(file)) {
-                val dirPath = file.toAbsolutePath().toString()
-                Paths.get(root, rebase(dirPath)).toFile().mkdirsOrFail()
-            } else {
-                val filePath = file.toAbsolutePath().toString()
-                Paths.get(root, rebase(filePath)).toFile().writeBytes(
-                    javaClass.getResourceAsStream(filePath).readBytes()
-                )
-            }
-        }
-    }
-
-    private fun File.mkdirsOrFail() {
-        if (!mkdirs() && !exists()) {
-            throw IOException("Failed to create directory $this")
-        }
-    }
-
-    private fun getFileSystemForURI(uri: URI): FileSystem =
-        try {
-            FileSystems.newFileSystem(uri, emptyMap<String, Any>())
-        } catch (e: FileSystemAlreadyExistsException) {
-            FileSystems.getFileSystem(uri)
-        }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/OutputWriter.kt b/core/src/main/kotlin/renderers/OutputWriter.kt
deleted file mode 100644
index e317f8ef..00000000
--- a/core/src/main/kotlin/renderers/OutputWriter.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package org.jetbrains.dokka.renderers
-
-interface OutputWriter {
-
-    fun write(path: String, text: String, ext: String)
-    fun writeResources(pathFrom: String, pathTo: String)
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
deleted file mode 100644
index 65d2f794..00000000
--- a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
+++ /dev/null
@@ -1,121 +0,0 @@
-package org.jetbrains.dokka.resolvers
-
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.utilities.htmlEscape
-import java.util.*
-
-private const val PAGE_WITH_CHILDREN_SUFFIX = "index"
-
-open class DefaultLocationProvider(
-    protected val pageGraphRoot: RootPageNode,
-    protected val dokkaContext: DokkaContext
-) : LocationProvider {
-    protected val extension = ".html"
-
-    protected val pagesIndex: Map<DRI, ContentPage> = pageGraphRoot.asSequence().filterIsInstance<ContentPage>()
-        .map { it.dri.map { dri -> dri to it } }.flatten()
-        .groupingBy { it.first }
-        .aggregate { dri, _, (_, page), first ->
-            if (first) page else throw AssertionError("Multiple pages associated with dri: $dri")
-        }
-
-    protected val pathsIndex: Map<PageNode, List<String>> = IdentityHashMap<PageNode, List<String>>().apply {
-        fun registerPath(page: PageNode, prefix: List<String>) {
-            val newPrefix = prefix + page.pathName
-            put(page, newPrefix)
-            page.children.forEach { registerPath(it, newPrefix) }
-        }
-        put(pageGraphRoot, emptyList())
-        pageGraphRoot.children.forEach { registerPath(it, emptyList()) }
-    }
-
-    override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String =
-        pathTo(node, context) + if (!skipExtension) extension else ""
-
-    override fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode?): String =
-        pagesIndex[dri]?.let { resolve(it, context) } ?:
-        // Not found in PageGraph, that means it's an external link
-        ExternalLocationProvider.getLocation(dri,
-            this.dokkaContext.configuration.passesConfigurations
-                .filter { passConfig ->
-                    platforms.toSet()
-                        .contains(PlatformData(passConfig.moduleName, passConfig.analysisPlatform, passConfig.targets))
-                } // TODO: change targets to something better?
-                .flatMap { it.externalDocumentationLinks }.distinct()
-        )
-
-    override fun resolveRoot(node: PageNode): String =
-        pathTo(pageGraphRoot, node).removeSuffix(PAGE_WITH_CHILDREN_SUFFIX)
-
-    override fun ancestors(node: PageNode): List<PageNode> =
-        generateSequence(node) { it.parent() }.toList()
-
-    protected open fun pathTo(node: PageNode, context: PageNode?): String {
-        fun pathFor(page: PageNode) = pathsIndex[page] ?: throw AssertionError(
-            "${page::class.simpleName}(${page.name}) does not belong to current page graph so it is impossible to compute its path"
-        )
-
-        val contextNode =
-            if (context?.children?.isEmpty() == true && context.parent() != null) context.parent() else context
-        val nodePath = pathFor(node)
-        val contextPath = contextNode?.let { pathFor(it) }.orEmpty()
-
-        val commonPathElements = nodePath.asSequence().zip(contextPath.asSequence())
-            .takeWhile { (a, b) -> a == b }.count()
-
-        return (List(contextPath.size - commonPathElements) { ".." } + nodePath.drop(commonPathElements) +
-                if (node.children.isNotEmpty()) listOf(PAGE_WITH_CHILDREN_SUFFIX) else emptyList()).joinToString("/")
-    }
-
-    private fun PageNode.parent() = pageGraphRoot.parentMap[this]
-}
-
-fun DRI.toJavadocLocation(jdkVersion: Int): String { // TODO: classes without packages?
-    val packageLink = packageName?.replace(".", "/")
-    if (classNames == null) {
-        return "$packageLink/package-summary.html".htmlEscape()
-    }
-    val classLink = if (packageLink == null) "$classNames.html" else "$packageLink/$classNames.html"
-    if (callable == null) {
-        return classLink.htmlEscape()
-    }
-
-    val callableLink = "$classLink#${callable.name}" + when {
-        jdkVersion < 8 -> "(${callable.params.joinToString(", ")})"
-        jdkVersion < 10 -> "-${callable.params.joinToString("-")}-"
-        else -> "(${callable.params.joinToString(",")})"
-    }
-
-    return callableLink.htmlEscape()
-}
-
-fun DRI.toDokkaLocation(extension: String): String { // TODO: classes without packages?
-    if (classNames == null) {
-        return "$packageName/index$extension"
-    }
-    val classLink = if (packageName == null) {
-        ""
-    } else {
-        "$packageName/"
-    } + classNames.split('.').joinToString("/", transform = ::identifierToFilename)
-
-    if (callable == null) {
-        return "$classLink/index$extension"
-    }
-
-    return "$classLink/${identifierToFilename(callable.name)}$extension"
-}
-
-private val reservedFilenames = setOf("index", "con", "aux", "lst", "prn", "nul", "eof", "inp", "out")
-
-private fun identifierToFilename(name: String): String {
-    if (name.isEmpty()) return "--root--"
-    val escaped = name.replace('<', '-').replace('>', '-')
-    val lowercase = escaped.replace("[A-Z]".toRegex()) { matchResult -> "-" + matchResult.value.toLowerCase() }
-    return if (lowercase in reservedFilenames) "--$lowercase--" else lowercase
-}
-
-private val PageNode.pathName: String
-    get() = if (this is PackagePageNode) name else identifierToFilename(name)
diff --git a/core/src/main/kotlin/resolvers/ExternalLocationProvider.kt b/core/src/main/kotlin/resolvers/ExternalLocationProvider.kt
deleted file mode 100644
index d3d8fa0d..00000000
--- a/core/src/main/kotlin/resolvers/ExternalLocationProvider.kt
+++ /dev/null
@@ -1,99 +0,0 @@
-package org.jetbrains.dokka.resolvers
-
-import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
-import org.jetbrains.dokka.links.DRI
-import java.net.HttpURLConnection
-import java.net.URL
-import java.net.URLConnection
-
-object ExternalLocationProvider { // TODO: Refactor this!!!
-    private const val DOKKA_PARAM_PREFIX = "\$dokka."
-
-    private val cache: MutableMap<URL, LocationInfo> = mutableMapOf()
-
-    fun getLocation(dri: DRI, externalDocumentationLinks: List<ExternalDocumentationLink>): String {
-        val toResolve: MutableList<ExternalDocumentationLink> = mutableListOf()
-        for(link in externalDocumentationLinks){
-            val info = cache[link.packageListUrl]
-            if(info == null) {
-                toResolve.add(link)
-            } else if(info.packages.contains(dri.packageName)) {
-                return link.url.toExternalForm() + getLink(dri, info)
-            }
-        }
-        // Not in cache, resolve packageLists
-        while (toResolve.isNotEmpty()){
-            val link = toResolve.first().also { toResolve.remove(it) }
-            val locationInfo = loadPackageList(link.packageListUrl)
-            if(locationInfo.packages.contains(dri.packageName)) {
-                return link.url.toExternalForm() + getLink(dri, locationInfo)
-            }
-        }
-        return ""
-    }
-
-    private fun getLink(dri: DRI, locationInfo: LocationInfo): String = when(locationInfo.format) {
-        "javadoc" ->  dri.toJavadocLocation(8)
-        "kotlin-website-html", "html" -> locationInfo.locations[dri.packageName + "." + dri.classNames] ?: dri.toDokkaLocation(".html")
-        "markdown" -> locationInfo.locations[dri.packageName + "." + dri.classNames] ?: dri.toDokkaLocation(".md")
-        // TODO: rework this
-        else -> throw RuntimeException("Unrecognized format")
-    }
-
-
-    private fun loadPackageList(url: URL): LocationInfo {
-        val packageListStream = url.doOpenConnectionToReadContent().getInputStream()
-        val (params, packages) =
-            packageListStream
-                .bufferedReader()
-                .useLines { lines -> lines.partition { it.startsWith(DOKKA_PARAM_PREFIX) } }
-
-        val paramsMap = params.asSequence()
-            .map { it.removePrefix(DOKKA_PARAM_PREFIX).split(":", limit = 2) }
-            .groupBy({ (key, _) -> key }, { (_, value) -> value })
-
-        val format = paramsMap["format"]?.singleOrNull() ?: "javadoc"
-
-        val locations = paramsMap["location"].orEmpty()
-            .map { it.split("\u001f", limit = 2) }
-            .map { (key, value) -> key to value }
-            .toMap()
-
-        val info = LocationInfo(format, packages.toSet(), locations)
-        cache[url] = info
-        return info
-    }
-
-    private fun URL.doOpenConnectionToReadContent(timeout: Int = 10000, redirectsAllowed: Int = 16): URLConnection {
-        val connection = this.openConnection().apply {
-            connectTimeout = timeout
-            readTimeout = timeout
-        }
-
-        when (connection) {
-            is HttpURLConnection -> {
-                return when (connection.responseCode) {
-                    in 200..299 -> {
-                        connection
-                    }
-                    HttpURLConnection.HTTP_MOVED_PERM,
-                    HttpURLConnection.HTTP_MOVED_TEMP,
-                    HttpURLConnection.HTTP_SEE_OTHER -> {
-                        if (redirectsAllowed > 0) {
-                            val newUrl = connection.getHeaderField("Location")
-                            URL(newUrl).doOpenConnectionToReadContent(timeout, redirectsAllowed - 1)
-                        } else {
-                            throw RuntimeException("Too many redirects")
-                        }
-                    }
-                    else -> {
-                        throw RuntimeException("Unhandled http code: ${connection.responseCode}")
-                    }
-                }
-            }
-            else -> return connection
-        }
-    }
-    data class LocationInfo(val format: String, val packages: Set<String>, val locations: Map<String, String>)
-
-}
diff --git a/core/src/main/kotlin/resolvers/LocationProvider.kt b/core/src/main/kotlin/resolvers/LocationProvider.kt
deleted file mode 100644
index 3bc9ab72..00000000
--- a/core/src/main/kotlin/resolvers/LocationProvider.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.jetbrains.dokka.resolvers
-
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.ContentPage
-import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.pages.PlatformData
-
-interface LocationProvider {
-    fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode? = null): String
-    fun resolve(node: PageNode, context: PageNode? = null, skipExtension: Boolean = false): String
-    fun resolveRoot(node: PageNode): String
-    fun ancestors(node: PageNode): List<PageNode>
-}
diff --git a/core/src/main/kotlin/resolvers/LocationProviderFactory.kt b/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
deleted file mode 100644
index 782795de..00000000
--- a/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.jetbrains.dokka.resolvers
-
-import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.pages.RootPageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-
-interface LocationProviderFactory {
-    fun getLocationProvider(pageNode: RootPageNode): LocationProvider
-}
-
-class DefaultLocationProviderFactory(val context: DokkaContext) : LocationProviderFactory {
-
-    override fun getLocationProvider(pageNode: RootPageNode)  = DefaultLocationProvider(pageNode, context)
-}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index 9b6e9b1a..fd842dc0 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -1,6 +1,11 @@
 package org.jetbrains.dokka.base
 
 import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.base.renderers.FileWriter
+import org.jetbrains.dokka.base.renderers.OutputWriter
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.base.resolvers.DefaultLocationProviderFactory
+import org.jetbrains.dokka.base.resolvers.LocationProviderFactory
 import org.jetbrains.dokka.base.transformers.descriptors.DefaultDescriptorToDocumentationTranslator
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentableMerger
 import org.jetbrains.dokka.base.transformers.documentables.DefaultDocumentablesToPageTranslator
@@ -12,11 +17,12 @@ import org.jetbrains.dokka.base.transformers.pages.merger.PageNodeMerger
 import org.jetbrains.dokka.base.transformers.pages.merger.SameMethodNamePageMergerStrategy
 import org.jetbrains.dokka.base.transformers.psi.DefaultPsiToDocumentationTranslator
 import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.renderers.html.HtmlRenderer
 
 class DokkaBase : DokkaPlugin() {
     val pageMergerStrategy by extensionPoint<PageMergerStrategy>()
     val commentsToContentConverter by extensionPoint<CommentsToContentConverter>()
+    val locationproviderFactory by extensionPoint<LocationProviderFactory>()
+    val outputWriter by extensionPoint<OutputWriter>()
 
     val descriptorToDocumentationTranslator by extending(isFallback = true) {
         CoreExtensions.descriptorToDocumentationTranslator providing ::DefaultDescriptorToDocumentationTranslator
@@ -57,4 +63,12 @@ class DokkaBase : DokkaPlugin() {
     val htmlRenderer by extending {
         CoreExtensions.renderer providing ::HtmlRenderer applyIf { format == "html" }
     }
+
+    val locationProvider by extending(isFallback = true) {
+        locationproviderFactory providing ::DefaultLocationProviderFactory
+    }
+
+    val fileWriter by extending(isFallback = true) {
+        outputWriter providing ::FileWriter
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
index c6183cf3..951545d2 100644
--- a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -1,18 +1,19 @@
 package org.jetbrains.dokka.base.renderers
 
-import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.base.resolvers.LocationProvider
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.renderers.OutputWriter
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.querySingle
 import org.jetbrains.dokka.renderers.Renderer
-import org.jetbrains.dokka.resolvers.LocationProvider
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
 abstract class DefaultRenderer<T>(
     protected val context: DokkaContext
 ) : Renderer {
 
-    protected val outputWriter = context.single(CoreExtensions.outputWriter)
+    protected val outputWriter = context.plugin<DokkaBase>().querySingle { outputWriter }
 
     protected lateinit var locationProvider: LocationProvider
         private set
@@ -116,7 +117,7 @@ abstract class DefaultRenderer<T>(
         val newRoot = preprocessors.fold(root) { acc, t -> t(acc) }
 
         locationProvider =
-            context.single(CoreExtensions.locationProviderFactory).getLocationProvider(newRoot)
+            context.plugin<DokkaBase>().querySingle { locationproviderFactory }.getLocationProvider(newRoot)
 
         root.children<ModulePageNode>().forEach { renderPackageList(it) }
 
diff --git a/plugins/base/src/main/kotlin/renderers/FileWriter.kt b/plugins/base/src/main/kotlin/renderers/FileWriter.kt
new file mode 100644
index 00000000..5d3067fc
--- /dev/null
+++ b/plugins/base/src/main/kotlin/renderers/FileWriter.kt
@@ -0,0 +1,79 @@
+package org.jetbrains.dokka.base.renderers
+
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.renderers.OutputWriter
+import java.io.File
+import java.io.IOException
+import java.net.URI
+import java.nio.file.*
+
+class FileWriter(val context: DokkaContext): OutputWriter {
+    private val createdFiles: MutableSet<String> = mutableSetOf()
+    private val jarUriPrefix = "jar:file:"
+    private val root = context.configuration.outputDir
+
+    override fun write(path: String, text: String, ext: String) {
+        if (createdFiles.contains(path)) {
+            context.logger.error("An attempt to write ${root}/$path several times!")
+            return
+        }
+        createdFiles.add(path)
+
+        try {
+            val dir = Paths.get(root, path.dropLastWhile { it != '/' }).toFile()
+            dir.mkdirsOrFail()
+            Files.write(Paths.get(root, "$path$ext"), text.lines())
+        } catch (e: Throwable) {
+            context.logger.error("Failed to write $this. ${e.message}")
+            e.printStackTrace()
+        }
+    }
+
+    override fun writeResources(pathFrom: String, pathTo: String) =
+        if (javaClass.getResource(pathFrom).toURI().toString().startsWith(jarUriPrefix)) {
+            copyFromJar(pathFrom, pathTo)
+        } else {
+            copyFromDirectory(pathFrom, pathTo)
+        }
+
+
+    private fun copyFromDirectory(pathFrom: String, pathTo: String) {
+        val dest = Paths.get(root, pathTo).toFile()
+        val uri = javaClass.getResource(pathFrom).toURI()
+        File(uri).copyRecursively(dest, true)
+    }
+
+    private fun copyFromJar(pathFrom: String, pathTo: String) {
+        val rebase = fun(path: String) =
+            "$pathTo/${path.removePrefix(pathFrom)}"
+        val dest = Paths.get(root, pathTo).toFile()
+        dest.mkdirsOrFail()
+        val uri = javaClass.getResource(pathFrom).toURI()
+        val fs = getFileSystemForURI(uri)
+        val path = fs.getPath(pathFrom)
+        for (file in Files.walk(path).iterator()) {
+            if (Files.isDirectory(file)) {
+                val dirPath = file.toAbsolutePath().toString()
+                Paths.get(root, rebase(dirPath)).toFile().mkdirsOrFail()
+            } else {
+                val filePath = file.toAbsolutePath().toString()
+                Paths.get(root, rebase(filePath)).toFile().writeBytes(
+                    javaClass.getResourceAsStream(filePath).readBytes()
+                )
+            }
+        }
+    }
+
+    private fun File.mkdirsOrFail() {
+        if (!mkdirs() && !exists()) {
+            throw IOException("Failed to create directory $this")
+        }
+    }
+
+    private fun getFileSystemForURI(uri: URI): FileSystem =
+        try {
+            FileSystems.newFileSystem(uri, emptyMap<String, Any>())
+        } catch (e: FileSystemAlreadyExistsException) {
+            FileSystems.getFileSystem(uri)
+        }
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/OutputWriter.kt b/plugins/base/src/main/kotlin/renderers/OutputWriter.kt
new file mode 100644
index 00000000..a6fda51a
--- /dev/null
+++ b/plugins/base/src/main/kotlin/renderers/OutputWriter.kt
@@ -0,0 +1,7 @@
+package org.jetbrains.dokka.base.renderers
+
+interface OutputWriter {
+
+    fun write(path: String, text: String, ext: String)
+    fun writeResources(pathFrom: String, pathTo: String)
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index c9270681..8bf00043 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -1,4 +1,4 @@
-package org.jetbrains.dokka.renderers.html
+package org.jetbrains.dokka.base.renderers.html
 
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
@@ -7,7 +7,6 @@ import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.renderers.OutputWriter
 import java.io.File
 
 open class HtmlRenderer(
diff --git a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
index 4a2fb40d..ad574769 100644
--- a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
@@ -1,4 +1,4 @@
-package org.jetbrains.dokka.renderers.html
+package org.jetbrains.dokka.base.renderers.html
 
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
diff --git a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
index 09164d97..ecd2e89a 100644
--- a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -1,4 +1,4 @@
-package org.jetbrains.dokka.renderers.html
+package org.jetbrains.dokka.base.renderers.html
 
 import kotlinx.html.h1
 import kotlinx.html.id
diff --git a/plugins/base/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/DefaultLocationProvider.kt
new file mode 100644
index 00000000..2238b0c3
--- /dev/null
+++ b/plugins/base/src/main/kotlin/resolvers/DefaultLocationProvider.kt
@@ -0,0 +1,116 @@
+package org.jetbrains.dokka.base.resolvers
+
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.utilities.htmlEscape
+import java.util.*
+
+private const val PAGE_WITH_CHILDREN_SUFFIX = "index"
+
+open class DefaultLocationProvider(
+    protected val pageGraphRoot: RootPageNode,
+    protected val dokkaContext: DokkaContext
+) : LocationProvider {
+    protected val extension = ".html"
+
+    protected val pagesIndex: Map<DRI, ContentPage> = pageGraphRoot.asSequence().filterIsInstance<ContentPage>()
+        .map { it.dri.map { dri -> dri to it } }.flatten()
+        .groupingBy { it.first }
+        .aggregate { dri, _, (_, page), first ->
+            if (first) page else throw AssertionError("Multiple pages associated with dri: $dri")
+        }
+
+    protected val pathsIndex: Map<PageNode, List<String>> = IdentityHashMap<PageNode, List<String>>().apply {
+        fun registerPath(page: PageNode, prefix: List<String>) {
+            val newPrefix = prefix + page.pathName
+            put(page, newPrefix)
+            page.children.forEach { registerPath(it, newPrefix) }
+        }
+        put(pageGraphRoot, emptyList())
+        pageGraphRoot.children.forEach { registerPath(it, emptyList()) }
+    }
+
+    override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String =
+        pathTo(node, context) + if (!skipExtension) extension else ""
+
+    override fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode?): String =
+        pagesIndex[dri]?.let { resolve(it, context) } ?:
+        // Not found in PageGraph, that means it's an external link
+        ExternalLocationProvider.getLocation(dri,
+            this.dokkaContext.configuration.passesConfigurations
+                .filter { passConfig ->
+                    platforms.toSet()
+                        .contains(PlatformData(passConfig.moduleName, passConfig.analysisPlatform, passConfig.targets))
+                } // TODO: change targets to something better?
+                .flatMap { it.externalDocumentationLinks }.distinct()
+        )
+
+    override fun resolveRoot(node: PageNode): String =
+        pathTo(pageGraphRoot, node).removeSuffix(PAGE_WITH_CHILDREN_SUFFIX)
+
+    override fun ancestors(node: PageNode): List<PageNode> =
+        generateSequence(node) { it.parent() }.toList()
+
+    protected open fun pathTo(node: PageNode, context: PageNode?): String {
+        fun pathFor(page: PageNode) = pathsIndex[page] ?: throw AssertionError(
+            "${page::class.simpleName}(${page.name}) does not belong to current page graph so it is impossible to compute its path"
+        )
+
+        val contextNode =
+            if (context?.children?.isEmpty() == true && context.parent() != null) context.parent() else context
+        val nodePath = pathFor(node)
+        val contextPath = contextNode?.let { pathFor(it) }.orEmpty()
+
+        val commonPathElements = nodePath.asSequence().zip(contextPath.asSequence())
+            .takeWhile { (a, b) -> a == b }.count()
+
+        return (List(contextPath.size - commonPathElements) { ".." } + nodePath.drop(commonPathElements) +
+                if (node.children.isNotEmpty()) listOf(PAGE_WITH_CHILDREN_SUFFIX) else emptyList()).joinToString("/")
+    }
+
+    private fun PageNode.parent() = pageGraphRoot.parentMap[this]
+}
+
+fun DRI.toJavadocLocation(jdkVersion: Int): String { // TODO: classes without packages?
+    val packageLink = packageName?.replace(".", "/")
+    if (classNames == null) {
+        return "$packageLink/package-summary.html".htmlEscape()
+    }
+    val classLink = if (packageLink == null) "$classNames.html" else "$packageLink/$classNames.html"
+    val callableChecked = callable ?: return classLink.htmlEscape()
+
+    val callableLink = "$classLink#${callableChecked.name}" + when {
+        jdkVersion < 8 -> "(${callableChecked.params.joinToString(", ")})"
+        jdkVersion < 10 -> "-${callableChecked.params.joinToString("-")}-"
+        else -> "(${callableChecked.params.joinToString(",")})"
+    }
+
+    return callableLink.htmlEscape()
+}
+
+fun DRI.toDokkaLocation(extension: String): String { // TODO: classes without packages?
+    val classNamesChecked = classNames ?: return "$packageName/index$extension"
+
+    val classLink = if (packageName == null) {
+        ""
+    } else {
+        "$packageName/"
+    } + classNamesChecked.split('.').joinToString("/", transform = ::identifierToFilename)
+
+    val callableChecked = callable ?: return "$classLink/index$extension"
+
+    return "$classLink/${identifierToFilename(callableChecked.name)}$extension"
+}
+
+private val reservedFilenames = setOf("index", "con", "aux", "lst", "prn", "nul", "eof", "inp", "out")
+
+private fun identifierToFilename(name: String): String {
+    if (name.isEmpty()) return "--root--"
+    val escaped = name.replace('<', '-').replace('>', '-')
+    val lowercase = escaped.replace("[A-Z]".toRegex()) { matchResult -> "-" + matchResult.value.toLowerCase() }
+    return if (lowercase in reservedFilenames) "--$lowercase--" else lowercase
+}
+
+private val PageNode.pathName: String
+    get() = if (this is PackagePageNode) name else identifierToFilename(name)
diff --git a/plugins/base/src/main/kotlin/resolvers/DefaultLocationProviderFactory.kt b/plugins/base/src/main/kotlin/resolvers/DefaultLocationProviderFactory.kt
new file mode 100644
index 00000000..c649e22b
--- /dev/null
+++ b/plugins/base/src/main/kotlin/resolvers/DefaultLocationProviderFactory.kt
@@ -0,0 +1,9 @@
+package org.jetbrains.dokka.base.resolvers
+
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+
+class DefaultLocationProviderFactory(private val context: DokkaContext) : LocationProviderFactory {
+
+    override fun getLocationProvider(pageNode: RootPageNode)  = DefaultLocationProvider(pageNode, context)
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/resolvers/ExternalLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/ExternalLocationProvider.kt
new file mode 100644
index 00000000..7c0e9952
--- /dev/null
+++ b/plugins/base/src/main/kotlin/resolvers/ExternalLocationProvider.kt
@@ -0,0 +1,99 @@
+package org.jetbrains.dokka.base.resolvers
+
+import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
+import org.jetbrains.dokka.links.DRI
+import java.net.HttpURLConnection
+import java.net.URL
+import java.net.URLConnection
+
+object ExternalLocationProvider { // TODO: Refactor this!!!
+    private const val DOKKA_PARAM_PREFIX = "\$dokka."
+
+    private val cache: MutableMap<URL, LocationInfo> = mutableMapOf()
+
+    fun getLocation(dri: DRI, externalDocumentationLinks: List<ExternalDocumentationLink>): String {
+        val toResolve: MutableList<ExternalDocumentationLink> = mutableListOf()
+        for(link in externalDocumentationLinks){
+            val info = cache[link.packageListUrl]
+            if(info == null) {
+                toResolve.add(link)
+            } else if(info.packages.contains(dri.packageName)) {
+                return link.url.toExternalForm() + getLink(dri, info)
+            }
+        }
+        // Not in cache, resolve packageLists
+        while (toResolve.isNotEmpty()){
+            val link = toResolve.first().also { toResolve.remove(it) }
+            val locationInfo = loadPackageList(link.packageListUrl)
+            if(locationInfo.packages.contains(dri.packageName)) {
+                return link.url.toExternalForm() + getLink(dri, locationInfo)
+            }
+        }
+        return ""
+    }
+
+    private fun getLink(dri: DRI, locationInfo: LocationInfo): String = when(locationInfo.format) {
+        "javadoc" ->  dri.toJavadocLocation(8)
+        "kotlin-website-html", "html" -> locationInfo.locations[dri.packageName + "." + dri.classNames] ?: dri.toDokkaLocation(".html")
+        "markdown" -> locationInfo.locations[dri.packageName + "." + dri.classNames] ?: dri.toDokkaLocation(".md")
+        // TODO: rework this
+        else -> throw RuntimeException("Unrecognized format")
+    }
+
+
+    private fun loadPackageList(url: URL): LocationInfo {
+        val packageListStream = url.doOpenConnectionToReadContent().getInputStream()
+        val (params, packages) =
+            packageListStream
+                .bufferedReader()
+                .useLines { lines -> lines.partition { it.startsWith(DOKKA_PARAM_PREFIX) } }
+
+        val paramsMap = params.asSequence()
+            .map { it.removePrefix(DOKKA_PARAM_PREFIX).split(":", limit = 2) }
+            .groupBy({ (key, _) -> key }, { (_, value) -> value })
+
+        val format = paramsMap["format"]?.singleOrNull() ?: "javadoc"
+
+        val locations = paramsMap["location"].orEmpty()
+            .map { it.split("\u001f", limit = 2) }
+            .map { (key, value) -> key to value }
+            .toMap()
+
+        val info = LocationInfo(format, packages.toSet(), locations)
+        cache[url] = info
+        return info
+    }
+
+    private fun URL.doOpenConnectionToReadContent(timeout: Int = 10000, redirectsAllowed: Int = 16): URLConnection {
+        val connection = this.openConnection().apply {
+            connectTimeout = timeout
+            readTimeout = timeout
+        }
+
+        when (connection) {
+            is HttpURLConnection -> {
+                return when (connection.responseCode) {
+                    in 200..299 -> {
+                        connection
+                    }
+                    HttpURLConnection.HTTP_MOVED_PERM,
+                    HttpURLConnection.HTTP_MOVED_TEMP,
+                    HttpURLConnection.HTTP_SEE_OTHER -> {
+                        if (redirectsAllowed > 0) {
+                            val newUrl = connection.getHeaderField("Location")
+                            URL(newUrl).doOpenConnectionToReadContent(timeout, redirectsAllowed - 1)
+                        } else {
+                            throw RuntimeException("Too many redirects")
+                        }
+                    }
+                    else -> {
+                        throw RuntimeException("Unhandled http code: ${connection.responseCode}")
+                    }
+                }
+            }
+            else -> return connection
+        }
+    }
+    data class LocationInfo(val format: String, val packages: Set<String>, val locations: Map<String, String>)
+
+}
diff --git a/plugins/base/src/main/kotlin/resolvers/LocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/LocationProvider.kt
new file mode 100644
index 00000000..13f4563c
--- /dev/null
+++ b/plugins/base/src/main/kotlin/resolvers/LocationProvider.kt
@@ -0,0 +1,19 @@
+package org.jetbrains.dokka.base.resolvers
+
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.pages.RootPageNode
+
+interface LocationProvider {
+    fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode? = null): String
+    fun resolve(node: PageNode, context: PageNode? = null, skipExtension: Boolean = false): String
+    fun resolveRoot(node: PageNode): String
+    fun ancestors(node: PageNode): List<PageNode>
+}
+
+interface LocationProviderFactory {
+    fun getLocationProvider(pageNode: RootPageNode): LocationProvider
+}
+
-- 
cgit 


From 4dafa915b87f6cc0dc9d47029d61563ed1977c67 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 17 Feb 2020 12:40:25 +0100
Subject: Removes last remnants of default extensions

---
 core/src/main/kotlin/CoreExtensions.kt                |  5 -----
 core/src/main/kotlin/plugability/DefaultExtensions.kt | 13 -------------
 core/src/main/kotlin/plugability/DokkaContext.kt      | 17 ++++-------------
 plugins/base/src/main/kotlin/renderers/FileWriter.kt  |  1 -
 4 files changed, 4 insertions(+), 32 deletions(-)
 delete mode 100644 core/src/main/kotlin/plugability/DefaultExtensions.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/CoreExtensions.kt b/core/src/main/kotlin/CoreExtensions.kt
index c8314f4d..82a1c367 100644
--- a/core/src/main/kotlin/CoreExtensions.kt
+++ b/core/src/main/kotlin/CoreExtensions.kt
@@ -10,11 +10,6 @@ import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 import org.jetbrains.dokka.transformers.psi.PsiToDocumentationTranslator
 import kotlin.reflect.KProperty
 
-
-/**
- * Extension points declared by dokka core.
- * Default values are stored in [org.jetbrains.dokka.plugability.DefaultExtensions]
- */
 object CoreExtensions {
     val descriptorToDocumentationTranslator by coreExtension<DescriptorToDocumentationTranslator>()
     val psiToDocumentationTranslator by coreExtension<PsiToDocumentationTranslator>()
diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
deleted file mode 100644
index 798e0f1a..00000000
--- a/core/src/main/kotlin/plugability/DefaultExtensions.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.jetbrains.dokka.plugability
-
-import org.jetbrains.dokka.CoreExtensions
-
-internal object DefaultExtensions {
-
-
-    @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
-    internal fun <T : Any, E : ExtensionPoint<T>> get(point: E, fullContext: DokkaContext): List<T> =
-        when (point) {
-            else -> null
-        }.let { listOfNotNull( it ) as List<T> }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index bcf6e1e0..5d5a8ebf 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -14,7 +14,7 @@ import kotlin.reflect.full.createInstance
 interface DokkaContext {
     fun <T : DokkaPlugin> plugin(kclass: KClass<T>): T?
 
-    operator fun <T, E> get(point: E, askDefault: AskDefault = AskDefault.WhenEmpty): List<T>
+    operator fun <T, E> get(point: E): List<T>
             where T : Any, E : ExtensionPoint<T>
 
     fun <T, E> single(point: E): T where T : Any, E : ExtensionPoint<T>
@@ -94,13 +94,8 @@ private class DokkaContextConfigurationImpl(
     }
 
     @Suppress("UNCHECKED_CAST")
-    override operator fun <T, E> get(point: E, askDefault: AskDefault) where T : Any, E : ExtensionPoint<T> =
-        when (askDefault) {
-            AskDefault.Never -> actions(point).orEmpty()
-            AskDefault.Always -> actions(point).orEmpty() + DefaultExtensions.get(point, this)
-            AskDefault.WhenEmpty ->
-                actions(point)?.takeIf { it.isNotEmpty() } ?: DefaultExtensions.get(point, this)
-        } as List<T>
+    override operator fun <T, E> get(point: E) where T : Any, E : ExtensionPoint<T> =
+        actions(point).orEmpty() as List<T>
 
     @Suppress("UNCHECKED_CAST")
     override fun <T, E> single(point: E): T where T : Any, E : ExtensionPoint<T> {
@@ -110,7 +105,7 @@ private class DokkaContextConfigurationImpl(
 
         val extensions = extensions[point].orEmpty() as List<Extension<T>>
         return when (extensions.size) {
-            0 -> DefaultExtensions.get(point, this).single() ?: throwBadArity("none was")
+            0 -> throwBadArity("none was")
             1 -> extensions.single().action.get(this)
             else -> {
                 val notFallbacks = extensions.filterNot { it.isFallback }
@@ -166,7 +161,3 @@ private fun checkClasspath(classLoader: URLClassLoader) {
         )
     }
 }
-
-enum class AskDefault {
-    Always, Never, WhenEmpty
-}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/FileWriter.kt b/plugins/base/src/main/kotlin/renderers/FileWriter.kt
index 5d3067fc..6519a4af 100644
--- a/plugins/base/src/main/kotlin/renderers/FileWriter.kt
+++ b/plugins/base/src/main/kotlin/renderers/FileWriter.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.base.renderers
 
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.renderers.OutputWriter
 import java.io.File
 import java.io.IOException
 import java.net.URI
-- 
cgit 


From 8658fd40e3674e29ef10e1fc4289d26caea1e762 Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Thu, 5 Mar 2020 11:40:22 +0100
Subject: Add warning when unused extension points are found

---
 core/src/main/kotlin/DokkaGenerator.kt             |  2 ++
 core/src/main/kotlin/plugability/DokkaContext.kt   | 24 ++++++++++++++--------
 .../src/main/kotlin/testApi/context/MockContext.kt |  6 +++++-
 3 files changed, 23 insertions(+), 9 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index a3f72220..a260d5ad 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -54,6 +54,8 @@ class DokkaGenerator(
         report("Rendering")
         render(transformedPages, context)
 
+        context.unusedPoints.takeIf { it.isNotEmpty() }
+            ?.also { logger.warn("Unused extension points found: ${it.joinToString(", ")}") }
         logger.report()
     }.dump("\n\n === TIME MEASUREMENT ===\n")
 
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 5d5a8ebf..c5a08a56 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.utilities.DokkaLogger
 import java.io.File
 import java.net.URLClassLoader
 import java.util.*
@@ -22,6 +22,8 @@ interface DokkaContext {
     val logger: DokkaLogger
     val configuration: DokkaConfiguration
     val platforms: Map<PlatformData, EnvironmentAndFacade>
+    val unusedPoints: Collection<ExtensionPoint<*>>
+
 
     companion object {
         fun create(
@@ -43,7 +45,7 @@ interface DokkaContext {
     }
 }
 
-inline fun <reified T: DokkaPlugin> DokkaContext.plugin(): T = plugin(T::class)
+inline fun <reified T : DokkaPlugin> DokkaContext.plugin(): T = plugin(T::class)
     ?: throw java.lang.IllegalStateException("Plugin ${T::class.qualifiedName} is not present in context.")
 
 interface DokkaContextConfiguration {
@@ -58,6 +60,10 @@ private class DokkaContextConfigurationImpl(
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
     private val pluginStubs = mutableMapOf<KClass<*>, DokkaPlugin>()
     internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
+    val pointsUsed: MutableSet<ExtensionPoint<*>> = mutableSetOf()
+    val pointsPopulated: MutableSet<ExtensionPoint<*>> = mutableSetOf()
+    override val unusedPoints: Set<ExtensionPoint<*>>
+        get() = pointsPopulated - pointsUsed
 
     private enum class State {
         UNVISITED,
@@ -74,9 +80,9 @@ private class DokkaContextConfigurationImpl(
 
         fun visit(n: Extension<*>) {
             val state = verticesWithState[n]
-            if(state == State.VISITED)
+            if (state == State.VISITED)
                 return
-            if(state == State.VISITING)
+            if (state == State.VISITING)
                 throw Error("Detected cycle in plugins graph")
             verticesWithState[n] = State.VISITING
             adjacencyList[n]?.forEach { visit(it) }
@@ -84,24 +90,26 @@ private class DokkaContextConfigurationImpl(
             result += n
         }
 
-        for((vertex, state) in verticesWithState) {
-            if(state == State.UNVISITED)
+        for ((vertex, state) in verticesWithState) {
+            if (state == State.UNVISITED)
                 visit(vertex)
         }
         result.asReversed().forEach {
+            pointsPopulated += it.extensionPoint
             extensions.getOrPut(it.extensionPoint, ::mutableListOf) += it
         }
     }
 
     @Suppress("UNCHECKED_CAST")
     override operator fun <T, E> get(point: E) where T : Any, E : ExtensionPoint<T> =
-        actions(point).orEmpty() as List<T>
+        actions(point).also { pointsUsed += point }.orEmpty() as List<T>
 
     @Suppress("UNCHECKED_CAST")
     override fun <T, E> single(point: E): T where T : Any, E : ExtensionPoint<T> {
         fun throwBadArity(substitution: String): Nothing = throw IllegalStateException(
             "$point was expected to have exactly one extension registered, but $substitution found."
         )
+        pointsUsed += point
 
         val extensions = extensions[point].orEmpty() as List<Extension<T>>
         return when (extensions.size) {
@@ -109,7 +117,7 @@ private class DokkaContextConfigurationImpl(
             1 -> extensions.single().action.get(this)
             else -> {
                 val notFallbacks = extensions.filterNot { it.isFallback }
-                if (notFallbacks.size == 1)  notFallbacks.single().action.get(this) else throwBadArity("many were")
+                if (notFallbacks.size == 1) notFallbacks.single().action.get(this) else throwBadArity("many were")
             }
         }
     }
diff --git a/testApi/src/main/kotlin/testApi/context/MockContext.kt b/testApi/src/main/kotlin/testApi/context/MockContext.kt
index 758a4311..d3def4dc 100644
--- a/testApi/src/main/kotlin/testApi/context/MockContext.kt
+++ b/testApi/src/main/kotlin/testApi/context/MockContext.kt
@@ -15,7 +15,8 @@ import kotlin.reflect.full.memberProperties
 class MockContext(
     vararg extensions: Pair<ExtensionPoint<*>, (DokkaContext) -> Any>,
     private val testConfiguration: DokkaConfiguration? = null,
-    private val testPlatforms: Map<PlatformData, EnvironmentAndFacade>? = null
+    private val testPlatforms: Map<PlatformData, EnvironmentAndFacade>? = null,
+    private val unusedExtensionPoints: List<ExtensionPoint<*>>? = null
 ) : DokkaContext {
     private val extensionMap by lazy {
         extensions.groupBy(Pair<ExtensionPoint<*>, (DokkaContext) -> Any>::first) {
@@ -40,6 +41,9 @@ class MockContext(
 
     override val platforms: Map<PlatformData, EnvironmentAndFacade>
         get() = testPlatforms ?: throw IllegalStateException("This mock context doesn't provide platforms data")
+    override val unusedPoints: Collection<ExtensionPoint<*>>
+        get() = unusedExtensionPoints
+            ?: throw IllegalStateException("This mock context doesn't provide unused extension points")
 }
 
 private fun DokkaPlugin.injectContext(context: DokkaContext) {
-- 
cgit 


From f94bbdc3bfa66bf2d485007739ce19a3befda98c Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Wed, 4 Mar 2020 17:46:19 +0100
Subject: Combine multiple applyIf

---
 core/src/main/kotlin/model/Documentable.kt     | 5 -----
 core/src/main/kotlin/plugability/extensions.kt | 3 ++-
 2 files changed, 2 insertions(+), 6 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index e379adb9..22930bf2 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -343,11 +343,6 @@ enum class ExtraModifiers {
     OVERRIDE, DATA, CONST, DYNAMIC, EXTERNAL, INNER, LATEINIT, OPERATOR, TAILREC, VARARG
 }
 
-enum class ExtraModifiers {
-    STATIC, INLINE, INFIX, SUSPEND, REIFIED, CROSSINLINE, NOINLINE,
-    OVERRIDE, DATA, CONST, DYNAMIC, EXTERNAL, INNER, LATEINIT, OPERATOR, TAILREC, VARARG
-}
-
 private fun String.shorten(maxLength: Int) = lineSequence().first().let {
     if (it.length != length || it.length > maxLength) it.take(maxLength - 3) + "..." else it
 }
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index 46c356df..1f994e75 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -96,7 +96,8 @@ class ExtendingDSL(private val pluginClass: String, private val extensionName: S
         ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, block)
 
     infix fun <T : Any> Extension<T>.applyIf(condition: DokkaConfiguration.() -> Boolean): Extension<T> =
-        this.setCondition(condition)
+        this.setCondition { this@applyIf.condition(this) && condition(this) }
+
 }
 
 @ExtensionsDsl
-- 
cgit 


From 14f0d36f6ec9d192a5c46c2b8267dcb2f1d21aa1 Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Thu, 12 Mar 2020 15:23:07 +0100
Subject: Response to comments

---
 .../src/main/kotlin/model/properties/properties.kt |  3 ---
 core/src/main/kotlin/plugability/extensions.kt     | 29 ++++++++++++----------
 2 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/model/properties/properties.kt b/core/src/main/kotlin/model/properties/properties.kt
index 4c8b345f..7010d0df 100644
--- a/core/src/main/kotlin/model/properties/properties.kt
+++ b/core/src/main/kotlin/model/properties/properties.kt
@@ -1,8 +1,5 @@
 package org.jetbrains.dokka.model.properties
 
-import org.jetbrains.dokka.model.Documentable
-import org.jetbrains.dokka.model.ExtraModifiers
-
 interface ExtraProperty<in C : Any> {
     interface Key<in C : Any, T : Any> {
         fun mergeStrategyFor(left: T, right: T): MergeStrategy<C> = MergeStrategy.Fail {
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index 1f994e75..20b60469 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -15,7 +15,7 @@ abstract class Extension<T : Any> internal constructor(
     internal val extensionName: String,
     internal val action: LazyEvaluated<T>,
     internal val ordering: (OrderDsl.() -> Unit)? = null,
-    internal val condition: DokkaConfiguration.() -> Boolean = { true },
+    internal val conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
     internal val isFallback: Boolean
 ) {
     override fun toString() = "Extension: $pluginClass/$extensionName"
@@ -26,9 +26,12 @@ abstract class Extension<T : Any> internal constructor(
 
     override fun hashCode() = listOf(pluginClass, extensionName).hashCode()
 
-    abstract fun setCondition(condition: (DokkaConfiguration.() -> Boolean)): Extension<T>
+    abstract fun addCondition(condition: (DokkaConfiguration.() -> Boolean)): Extension<T>
 
     abstract fun markedAsFallback(): Extension<T>
+
+    open val condition: DokkaConfiguration.() -> Boolean
+        get() = { conditions.all { it(this) }}
 }
 
 class ExtensionOrdered<T : Any> internal constructor(
@@ -37,7 +40,7 @@ class ExtensionOrdered<T : Any> internal constructor(
     extensionName: String,
     action: LazyEvaluated<T>,
     ordering: (OrderDsl.() -> Unit),
-    condition: DokkaConfiguration.() -> Boolean = { true },
+    conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
     isFallback: Boolean = false
 ) : Extension<T>(
     extensionPoint,
@@ -45,14 +48,14 @@ class ExtensionOrdered<T : Any> internal constructor(
     extensionName,
     action,
     ordering,
-    condition,
+    conditions,
     isFallback
 ) {
-    override fun setCondition(condition: DokkaConfiguration.() -> Boolean) =
-        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, condition)
+    override fun addCondition(condition: DokkaConfiguration.() -> Boolean) =
+        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, conditions + condition)
 
     override fun markedAsFallback() =
-        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, condition, true)
+        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, conditions, true)
 }
 
 class ExtensionUnordered<T : Any> internal constructor(
@@ -60,7 +63,7 @@ class ExtensionUnordered<T : Any> internal constructor(
     pluginClass: String,
     extensionName: String,
     action: LazyEvaluated<T>,
-    condition: DokkaConfiguration.() -> Boolean = { true },
+    conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
     isFallback: Boolean = false
 ) : Extension<T>(
     extensionPoint,
@@ -68,14 +71,14 @@ class ExtensionUnordered<T : Any> internal constructor(
     extensionName,
     action,
     null,
-    condition,
+    conditions,
     isFallback
 ) {
-    override fun setCondition(condition: DokkaConfiguration.() -> Boolean) =
-        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, condition)
+    override fun addCondition(condition: DokkaConfiguration.() -> Boolean) =
+        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, conditions + condition)
 
     override fun markedAsFallback() =
-        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, condition, true)
+        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, conditions, true)
 }
 
 internal data class Ordering(val previous: Set<Extension<*>>, val following: Set<Extension<*>>)
@@ -96,7 +99,7 @@ class ExtendingDSL(private val pluginClass: String, private val extensionName: S
         ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, block)
 
     infix fun <T : Any> Extension<T>.applyIf(condition: DokkaConfiguration.() -> Boolean): Extension<T> =
-        this.setCondition { this@applyIf.condition(this) && condition(this) }
+        this.addCondition(condition)
 
 }
 
-- 
cgit 


From 9273d18c9edf7ea2aa265d53a9ae971e3e28a87d Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Fri, 14 Feb 2020 14:25:48 +0100
Subject: Add extension for html preprocessors

---
 .../main/kotlin/plugability/DefaultExtensions.kt   |  0
 plugins/base/src/main/kotlin/DokkaBase.kt          | 24 +++++++++++++++++++++-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt | 11 ++++------
 3 files changed, 27 insertions(+), 8 deletions(-)
 create mode 100644 core/src/main/kotlin/plugability/DefaultExtensions.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DefaultExtensions.kt b/core/src/main/kotlin/plugability/DefaultExtensions.kt
new file mode 100644
index 00000000..e69de29b
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index d236aa01..8934dd7f 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -3,7 +3,7 @@ package org.jetbrains.dokka.base
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.base.renderers.FileWriter
 import org.jetbrains.dokka.base.renderers.OutputWriter
-import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.base.renderers.html.*
 import org.jetbrains.dokka.base.resolvers.DefaultLocationProviderFactory
 import org.jetbrains.dokka.base.resolvers.LocationProviderFactory
 import org.jetbrains.dokka.base.signatures.KotlinSignatureProvider
@@ -21,6 +21,7 @@ import org.jetbrains.dokka.base.translators.descriptors.DefaultDescriptorToDocum
 import org.jetbrains.dokka.base.translators.documentables.DefaultDocumentableToPageTranslator
 import org.jetbrains.dokka.base.translators.psi.DefaultPsiToDocumentableTranslator
 import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.transformers.pages.PageTransformer
 
 class DokkaBase : DokkaPlugin() {
     val pageMergerStrategy by extensionPoint<PageMergerStrategy>()
@@ -28,6 +29,7 @@ class DokkaBase : DokkaPlugin() {
     val signatureProvider by extensionPoint<SignatureProvider>()
     val locationProviderFactory by extensionPoint<LocationProviderFactory>()
     val outputWriter by extensionPoint<OutputWriter>()
+    val htmlPreprocessors by extensionPoint<PageTransformer>()
 
     val descriptorToDocumentableTranslator by extending(isFallback = true) {
         CoreExtensions.descriptorToDocumentableTranslator providing ::DefaultDescriptorToDocumentableTranslator
@@ -94,4 +96,24 @@ class DokkaBase : DokkaPlugin() {
     val fileWriter by extending(isFallback = true) {
         outputWriter providing ::FileWriter
     }
+
+    val rootCreator by extending {
+        htmlPreprocessors with RootCreator
+    }
+
+    val navigationPageInstaller by extending {
+        htmlPreprocessors with NavigationPageInstaller order { after(rootCreator) }
+    }
+
+    val searchPageInstaller by extending {
+        htmlPreprocessors with SearchPageInstaller order { after(rootCreator) }
+    }
+
+    val resourceInstaller by extending {
+        htmlPreprocessors with ResourceInstaller order { after(rootCreator) }
+    }
+
+    val styleAndScriptsAppender by extending {
+        htmlPreprocessors with StyleAndScriptsAppender order { after(rootCreator) }
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 57915134..365405ed 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -2,11 +2,14 @@ package org.jetbrains.dokka.base.renderers.html
 
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.DefaultRenderer
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.DFunction
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.query
 import java.io.File
 
 open class HtmlRenderer(
@@ -15,13 +18,7 @@ open class HtmlRenderer(
 
     private val pageList = mutableListOf<String>()
 
-    override val preprocessors = listOf(
-        RootCreator,
-        SearchPageInstaller,
-        ResourceInstaller,
-        NavigationPageInstaller,
-        StyleAndScriptsAppender
-    )
+    override val preprocessors = context.plugin<DokkaBase>().query { htmlPreprocessors }
 
     override fun FlowContent.wrapGroup(
         node: ContentGroup,
-- 
cgit 


From 58126c324c30fff4f65fef7cc72aa715364ef358 Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Mon, 20 Apr 2020 23:10:22 +0200
Subject: Fix incorrect plugins paths when project is on a different filesystem
 than Gradle

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index c5a08a56..cefcd286 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -33,7 +33,8 @@ interface DokkaContext {
             pluginOverrides: List<DokkaPlugin>
         ): DokkaContext =
             DokkaContextConfigurationImpl(logger, configuration, platforms).apply {
-                configuration.pluginsClasspath.map { it.relativeTo(File(".").absoluteFile).toURI().toURL() }
+                // File(it.path) is a workaround for an incorrect filesystem in a File instance returned by Gradle.
+                configuration.pluginsClasspath.map { File(it.path).toURI().toURL() }
                     .toTypedArray()
                     .let { URLClassLoader(it, this.javaClass.classLoader) }
                     .also { checkClasspath(it) }
-- 
cgit 


From 7f9d595f604e269fb918dc69cf2f80c19aef58c2 Mon Sep 17 00:00:00 2001
From: Andrzej Ratajczak <andrzej.ratajczak98@gmail.com>
Date: Wed, 1 Apr 2020 17:02:18 +0200
Subject: Adds possibility to configure plugins

---
 core/src/main/kotlin/configuration.kt              |  3 +
 core/src/main/kotlin/defaultConfiguration.kt       |  3 +-
 core/src/main/kotlin/plugability/DokkaPlugin.kt    | 26 +++++++
 runners/cli/src/main/kotlin/cli/main.kt            |  2 +
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt | 87 ++++++++++++++--------
 .../dokka/gradle/configurationImplementations.kt   |  1 +
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |  2 +-
 runners/maven-plugin/src/main/kotlin/DokkaMojo.kt  |  3 +-
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |  4 +-
 9 files changed, 97 insertions(+), 34 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index 19835fa4..34671c4e 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -33,6 +33,7 @@ interface DokkaConfiguration {
     val passesConfigurations: List<PassConfiguration>
     val impliedPlatforms: List<String>
     val pluginsClasspath: List<File>
+    val pluginsConfiguration: Map<String, String>
 
     interface PassConfiguration {
         val moduleName: String
@@ -100,3 +101,5 @@ interface DokkaConfiguration {
         }
     }
 }
+
+
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index b0c12015..ae674ea1 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -10,7 +10,8 @@ data class DokkaConfigurationImpl(
     override val cacheRoot: String?,
     override val impliedPlatforms: List<String>,
     override val passesConfigurations: List<PassConfigurationImpl>,
-    override var pluginsClasspath: List<File>
+    override val pluginsClasspath: List<File>,
+    override val pluginsConfiguration: Map<String, String>
 ) : DokkaConfiguration
 
 data class PassConfigurationImpl (
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index d8fb7892..24f417d8 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -1,9 +1,12 @@
 package org.jetbrains.dokka.plugability
 
+import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.kotlin.utils.addToStdlib.cast
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
+import kotlin.reflect.full.createInstance
 
 private typealias ExtensionDelegate<T> = ReadOnlyProperty<DokkaPlugin, Extension<T>>
 
@@ -49,6 +52,18 @@ abstract class DokkaPlugin {
     }
 }
 
+interface Configurable {
+    val pluginsConfiguration: Map<String, String>
+}
+
+interface ConfigurableBlock
+
+inline fun <reified P : DokkaPlugin, reified T : ConfigurableBlock> Configurable.pluginConfiguration(block: T.() -> Unit) {
+    val instance = T::class.createInstance().apply(block)
+    pluginsConfiguration.cast<MutableMap<String, String>>()[P::class.qualifiedName!!] =
+        Gson().toJson(instance, T::class.java)
+}
+
 inline fun <reified P : DokkaPlugin, reified E : Any> P.query(extension: P.() -> ExtensionPoint<E>): List<E> =
     context?.let { it[extension()] } ?: throwIllegalQuery()
 
@@ -57,3 +72,14 @@ inline fun <reified P : DokkaPlugin, reified E : Any> P.querySingle(extension: P
 
 fun throwIllegalQuery(): Nothing =
     throw IllegalStateException("Querying about plugins is only possible with dokka context initialised")
+
+inline fun <reified T : DokkaPlugin, reified R : ConfigurableBlock> configuration(context: DokkaContext): ReadOnlyProperty<Any?, R> {
+    return object : ReadOnlyProperty<Any?, R> {
+        override fun getValue(thisRef: Any?, property: KProperty<*>): R {
+            return context.configuration.pluginsConfiguration.get(T::class.qualifiedName
+                ?: throw AssertionError("Plugin must be named class")).let {
+                    Gson().fromJson(it, R::class.java)
+            }
+        }
+    }
+}
\ 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 50aadf00..dca97ec6 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -54,6 +54,8 @@ open class GlobalArguments(parser: DokkaArgumentsParser) : DokkaConfiguration {
     ) {
         Arguments(parser).also { if(it.moduleName.isEmpty()) DokkaConsoleLogger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module") }
     }
+
+    override val pluginsConfiguration: Map<String, String> = mutableMapOf()
 }
 
 class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfiguration {
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 fda1017a..2018d3af 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
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.gradle
 
+import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 import org.gradle.api.*
 import org.gradle.api.artifacts.Configuration
@@ -14,13 +15,14 @@ import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.ReflectDsl
 import org.jetbrains.dokka.ReflectDsl.isNotInstance
 import org.jetbrains.dokka.gradle.ConfigurationExtractor.PlatformData
+import org.jetbrains.dokka.plugability.Configurable
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import java.io.File
 import java.net.URLClassLoader
 import java.util.concurrent.Callable
 import java.util.function.BiConsumer
 
-open class DokkaTask : DefaultTask() {
+open class DokkaTask : DefaultTask(), Configurable {
     private val ANDROID_REFERENCE_URL = Builder("https://developer.android.com/reference/").build()
     private val GLOBAL_PLATFORM_NAME = "global" // Used for copying perPackageOptions to other platforms
 
@@ -58,12 +60,14 @@ open class DokkaTask : DefaultTask() {
     @Input
     var impliedPlatforms: MutableList<String> = arrayListOf()
 
+    override val pluginsConfiguration: Map<String, String> = mutableMapOf()
+
     @Optional
     @Input
     var cacheRoot: String? = null
 
     @Classpath
-    lateinit var pluginsConfiguration: Configuration
+    lateinit var pluginsConfig: Configuration
 
     var multiplatform: NamedDomainObjectContainer<GradlePassConfigurationImpl>
         @Suppress("UNCHECKED_CAST")
@@ -80,19 +84,26 @@ open class DokkaTask : DefaultTask() {
     // Configure Dokka with closure in Gradle Kotlin DSL
     fun configuration(action: Action<in GradlePassConfigurationImpl>) = action.execute(configuration)
 
-    private val kotlinTasks: List<Task> by lazy { extractKotlinCompileTasks(configuration.collectKotlinTasks ?: { defaultKotlinTasks() }) }
+    private val kotlinTasks: List<Task> by lazy {
+        extractKotlinCompileTasks(
+            configuration.collectKotlinTasks ?: { defaultKotlinTasks() })
+    }
 
     private val configExtractor = ConfigurationExtractor(project)
 
     @Input
     var disableAutoconfiguration: Boolean = false
 
-    private var outputDiagnosticInfo: Boolean = false // Workaround for Gradle, which fires some methods (like collectConfigurations()) multiple times in its lifecycle
+    private var outputDiagnosticInfo: Boolean =
+        false // Workaround for Gradle, which fires some methods (like collectConfigurations()) multiple times in its lifecycle
 
     private fun loadFatJar() {
         if (ClassloaderContainer.fatJarClassLoader == null) {
             val jars = dokkaRuntime!!.resolve()
-            ClassloaderContainer.fatJarClassLoader = URLClassLoader(jars.map { it.toURI().toURL() }.toTypedArray(), ClassLoader.getSystemClassLoader().parent)
+            ClassloaderContainer.fatJarClassLoader = URLClassLoader(
+                jars.map { it.toURI().toURL() }.toTypedArray(),
+                ClassLoader.getSystemClassLoader().parent
+            )
         }
     }
 
@@ -102,7 +113,9 @@ open class DokkaTask : DefaultTask() {
 
         val taskContainer = project.tasks
 
-        val tasksByPath = paths.map { taskContainer.findByPath(it as String) ?: throw IllegalArgumentException("Task with path '$it' not found") }
+        val tasksByPath = paths.map {
+            taskContainer.findByPath(it as String) ?: throw IllegalArgumentException("Task with path '$it' not found")
+        }
 
         other
             .filter { it !is Task || it isNotInstance getAbstractKotlinCompileFor(it) }
@@ -116,11 +129,14 @@ open class DokkaTask : DefaultTask() {
         return (tasksByPath + other) as List<Task>
     }
 
-    private fun Iterable<File>.toSourceRoots(): List<GradleSourceRootImpl> = this.filter { it.exists() }.map { GradleSourceRootImpl().apply { path = it.path } }
-    private fun Iterable<String>.toProjects(): List<Project> = project.subprojects.toList().filter { this.contains(it.name) }
+    private fun Iterable<File>.toSourceRoots(): List<GradleSourceRootImpl> =
+        this.filter { it.exists() }.map { GradleSourceRootImpl().apply { path = it.path } }
+
+    private fun Iterable<String>.toProjects(): List<Project> =
+        project.subprojects.toList().filter { this.contains(it.name) }
 
     private fun collectSuppressedFiles(sourceRoots: List<SourceRoot>) =
-        if(project.isAndroidProject()) {
+        if (project.isAndroidProject()) {
             val generatedRoot = project.buildDir.resolve("generated").absoluteFile
             sourceRoots
                 .map { File(it.path) }
@@ -143,7 +159,8 @@ open class DokkaTask : DefaultTask() {
         try {
             loadFatJar()
 
-            val bootstrapClass = ClassloaderContainer.fatJarClassLoader!!.loadClass("org.jetbrains.dokka.DokkaBootstrapImpl")
+            val bootstrapClass =
+                ClassloaderContainer.fatJarClassLoader!!.loadClass("org.jetbrains.dokka.DokkaBootstrapImpl")
             val bootstrapInstance = bootstrapClass.constructors.first().newInstance()
             val bootstrapProxy: DokkaBootstrap =
                 automagicTypedProxy(javaClass.classLoader, bootstrapInstance)
@@ -181,7 +198,8 @@ open class DokkaTask : DefaultTask() {
             cacheRoot = cacheRoot
             impliedPlatforms = impliedPlatforms
             passesConfigurations = defaultModulesConfiguration
-            pluginsClasspath = pluginsConfiguration.resolve().toList()
+            pluginsClasspath = pluginsConfig.resolve().toList()
+            pluginsConfiguration = this@DokkaTask.pluginsConfiguration
         }
     }
 
@@ -206,15 +224,17 @@ open class DokkaTask : DefaultTask() {
 
         val baseConfig = configExtractor.extractConfiguration(userConfig.name, userConfig.androidVariant)
             ?.let { mergeUserConfigurationAndPlatformData(userConfig, it) }
-                ?: if (this.isMultiplatformProject()) {
-                    if (outputDiagnosticInfo)
-                        logger.warn("Could not find target with name: ${userConfig.name} in Kotlin Gradle Plugin, " +
-                                "using only user provided configuration for this target")
-                    userConfig
-                } else {
-                    logger.warn("Could not find target with name: ${userConfig.name} in Kotlin Gradle Plugin")
-                    collectFromSinglePlatformOldPlugin()
-                }
+            ?: if (this.isMultiplatformProject()) {
+                if (outputDiagnosticInfo)
+                    logger.warn(
+                        "Could not find target with name: ${userConfig.name} in Kotlin Gradle Plugin, " +
+                                "using only user provided configuration for this target"
+                    )
+                userConfig
+            } else {
+                logger.warn("Could not find target with name: ${userConfig.name} in Kotlin Gradle Plugin")
+                collectFromSinglePlatformOldPlugin()
+            }
 
         return if (subProjects.isNotEmpty()) {
             try {
@@ -224,9 +244,11 @@ open class DokkaTask : DefaultTask() {
                         ConfigurationExtractor(subProject).extractConfiguration(config.name, config.androidVariant)!!
                     )
                 }
-            } catch(e: NullPointerException) {
-                logger.warn("Cannot extract sources from subProjects. Do you have the Kotlin plugin in version 1.3.30+ " +
-                        "and the Kotlin plugin applied in the root project?")
+            } catch (e: NullPointerException) {
+                logger.warn(
+                    "Cannot extract sources from subProjects. Do you have the Kotlin plugin in version 1.3.30+ " +
+                            "and the Kotlin plugin applied in the root project?"
+                )
                 baseConfig
             }
         } else {
@@ -237,11 +259,14 @@ open class DokkaTask : DefaultTask() {
     private fun collectFromSinglePlatformOldPlugin() =
         configExtractor.extractFromKotlinTasks(kotlinTasks)
             ?.let { mergeUserConfigurationAndPlatformData(configuration, it) }
-                ?: configExtractor.extractFromJavaPlugin()
-                    ?.let { mergeUserConfigurationAndPlatformData(configuration, it) }
-                ?: configuration
-
-    private fun mergeUserConfigurationAndPlatformData(userConfig: GradlePassConfigurationImpl, autoConfig: PlatformData) =
+            ?: configExtractor.extractFromJavaPlugin()
+                ?.let { mergeUserConfigurationAndPlatformData(configuration, it) }
+            ?: configuration
+
+    private fun mergeUserConfigurationAndPlatformData(
+        userConfig: GradlePassConfigurationImpl,
+        autoConfig: PlatformData
+    ) =
         userConfig.copy().apply {
             sourceRoots.addAll(userConfig.sourceRoots.union(autoConfig.sourceRoots.toSourceRoots()).distinct())
             classpath = userConfig.classpath.union(autoConfig.classpath.map { it.absolutePath }).distinct()
@@ -256,10 +281,11 @@ open class DokkaTask : DefaultTask() {
         if (config.moduleName == "") {
             config.moduleName = project.name
         }
-        if (config.targets.isEmpty() && multiplatform.isNotEmpty()){
+        if (config.targets.isEmpty() && multiplatform.isNotEmpty()) {
             config.targets = listOf(config.name)
         }
-        config.classpath = (config.classpath as List<Any>).map { it.toString() }.distinct() // Workaround for Groovy's GStringImpl
+        config.classpath =
+            (config.classpath as List<Any>).map { it.toString() }.distinct() // Workaround for Groovy's GStringImpl
         config.sourceRoots = config.sourceRoots.distinct().toMutableList()
         config.samples = config.samples.map { project.file(it).absolutePath }
         config.includes = config.includes.map { project.file(it).absolutePath }
@@ -314,3 +340,4 @@ open class DokkaTask : DefaultTask() {
         }
     }
 }
+
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
index 3b3b3f96..570da5f3 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
@@ -125,6 +125,7 @@ class GradleDokkaConfigurationImpl: DokkaConfiguration {
     override var impliedPlatforms: List<String> = emptyList()
     override var passesConfigurations: List<GradlePassConfigurationImpl> = emptyList()
     override var pluginsClasspath: List<File> = emptyList()
+    override var pluginsConfiguration: Map<String, String> = mutableMapOf()
 }
 
 class GradlePackageOptionsImpl: PackageOptions, Serializable {
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 2ece238f..1d93a310 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
@@ -48,7 +48,7 @@ open class DokkaPlugin : Plugin<Project> {
             task.multiplatform = project.container(GradlePassConfigurationImpl::class.java)
             task.configuration = GradlePassConfigurationImpl()
             task.dokkaRuntime = runtimeConfiguration
-            task.pluginsConfiguration = pluginsConfiguration
+            task.pluginsConfig = pluginsConfiguration
             task.outputDirectory = File(project.buildDir, DOKKA_TASK_NAME).absolutePath
         }
     }
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 49c6fba6..24d95ab4 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -249,7 +249,8 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             },
             generateIndexPages = generateIndexPages,
             pluginsClasspath = getArtifactByAether("org.jetbrains.dokka", "dokka-base", dokkaVersion) +
-                    dokkaPlugins.map { getArtifactByAether(it.groupId, it.artifactId, it.version) }.flatten()
+                    dokkaPlugins.map { getArtifactByAether(it.groupId, it.artifactId, it.version) }.flatten(),
+            pluginsConfiguration = mutableMapOf() //TODO implement as it is in Gradle
         )
 
         val gen = DokkaGenerator(configuration, logger)
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index 26b9a4b6..6c132d3c 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -140,6 +140,7 @@ abstract class AbstractCoreTest {
         var generateIndexPages: Boolean = true
         var cacheRoot: String? = null
         var pluginsClasspath: List<File> = emptyList()
+        var pluginsConfigurations: Map<String, String> = emptyMap()
         private val passesConfigurations = mutableListOf<PassConfigurationImpl>()
         fun build() = DokkaConfigurationImpl(
             outputDir = outputDir,
@@ -148,7 +149,8 @@ abstract class AbstractCoreTest {
             cacheRoot = cacheRoot,
             impliedPlatforms = emptyList(),
             passesConfigurations = passesConfigurations,
-            pluginsClasspath = pluginsClasspath
+            pluginsClasspath = pluginsClasspath,
+            pluginsConfiguration = pluginsConfigurations
         )
 
         fun passes(block: Passes.() -> Unit) {
-- 
cgit 


From 3f2a790190da4f40ea6d8a976aa1929b2a1b002b Mon Sep 17 00:00:00 2001
From: Błażej Kardyś <bkardys@virtuslab.com>
Date: Tue, 5 May 2020 17:45:12 +0200
Subject: Changing approach from platform-driven to source-set-driven

---
 .idea/compiler.xml                                 |  36 +++
 core/src/main/kotlin/DokkaGenerator.kt             |  36 +--
 core/src/main/kotlin/configuration.kt              |   6 +-
 core/src/main/kotlin/defaultConfiguration.kt       |   2 +
 core/src/main/kotlin/model/Documentable.kt         | 168 ++++++--------
 core/src/main/kotlin/model/SourceSetData.kt        |  23 ++
 core/src/main/kotlin/model/aditionalExtras.kt      |   4 +-
 core/src/main/kotlin/model/documentableUtils.kt    |  15 +-
 core/src/main/kotlin/pages/ContentNodes.kt         |  29 +--
 core/src/main/kotlin/pages/PageNodes.kt            |   5 +-
 core/src/main/kotlin/plugability/DokkaContext.kt   |  14 +-
 .../PreMergeDocumentableTransformer.kt             |   2 +-
 .../sources/SourceToDocumentableTranslator.kt      |   4 +-
 plugins/base/src/main/kotlin/DokkaBase.kt          |   6 +-
 .../src/main/kotlin/renderers/DefaultRenderer.kt   |  21 +-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |  58 ++---
 .../main/kotlin/renderers/html/NavigationPage.kt   |   4 +-
 .../resolvers/local/DefaultLocationProvider.kt     |   9 +-
 .../kotlin/resolvers/local/LocationProvider.kt     |   4 +-
 .../kotlin/signatures/KotlinSignatureProvider.kt   |  35 ++-
 .../documentables/ActualTypealiasAdder.kt          |   8 +-
 .../documentables/DefaultDocumentableMerger.kt     | 233 ++++++++-----------
 .../documentables/DocumentableVisibilityFilter.kt  |  55 +++--
 .../InheritorsExtractorTransformer.kt              |  23 +-
 .../ModuleAndPackageDocumentationTransformer.kt    |  42 ++--
 .../pages/comments/CommentsToContentConverter.kt   |   3 +-
 .../pages/comments/DocTagToContentConverter.kt     |  33 +--
 .../merger/SameMethodNamePageMergerStrategy.kt     |   2 +-
 .../pages/samples/SamplesTransformer.kt            |  25 +-
 .../pages/sourcelinks/SourceLinksTransformer.kt    |  23 +-
 .../DefaultDescriptorToDocumentableTranslator.kt   | 252 ++++++++++-----------
 .../documentables/DefaultPageCreator.kt            | 111 +++++----
 .../documentables/PageContentBuilder.kt            |  98 ++++----
 .../psi/DefaultPsiToDocumentableTranslator.kt      |  57 +++--
 .../src/test/kotlin/expect/AbstractExpectTest.kt   |   2 +-
 .../kotlin/linkableContent/LinkableContentTest.kt  |   6 +
 plugins/base/src/test/kotlin/model/ClassesTest.kt  |  20 +-
 .../base/src/test/kotlin/model/InheritorsTest.kt   |  10 +-
 plugins/base/src/test/kotlin/model/JavaTest.kt     |   4 +-
 plugins/base/src/test/kotlin/model/PackagesTest.kt |   4 +-
 .../test/kotlin/renderers/RenderingOnlyTestBase.kt |   7 +-
 .../renderers/html/PlatformDependentHintTest.kt    | 120 ----------
 .../renderers/html/SourceSetDependentHintTest.kt   | 121 ++++++++++
 .../annotatedFunction/out/html/navigation.html     |   6 +-
 .../out/html/root/[jvm root]/f.html                |  32 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/f.html               |  32 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../annotatedFunction/out/html/root/index.html     |   4 +-
 .../annotatedFunction/out/html/root/package-list   |   4 +-
 .../annotatedFunction/out/html/scripts/pages.js    |   0
 .../out/html/navigation.html                       |  10 +-
 .../out/html/root/[jvm root]/-fancy/-init-.html    |  32 ---
 .../out/html/root/[jvm root]/-fancy/equals.html    |  32 ---
 .../out/html/root/[jvm root]/-fancy/hash-code.html |  32 ---
 .../out/html/root/[jvm root]/-fancy/index.html     | 102 ---------
 .../out/html/root/[jvm root]/-fancy/to-string.html |  32 ---
 .../out/html/root/[jvm root]/f.html                |  32 ---
 .../out/html/root/[jvm root]/index.html            |  69 ------
 .../out/html/root/[main root]/-fancy/-init-.html   |  32 +++
 .../out/html/root/[main root]/-fancy/equals.html   |  32 +++
 .../html/root/[main root]/-fancy/hash-code.html    |  32 +++
 .../out/html/root/[main root]/-fancy/index.html    | 102 +++++++++
 .../html/root/[main root]/-fancy/to-string.html    |  32 +++
 .../out/html/root/[main root]/f.html               |  32 +++
 .../out/html/root/[main root]/index.html           |  69 ++++++
 .../out/html/root/index.html                       |   4 +-
 .../out/html/root/package-list                     |  10 +-
 .../expect/function/out/html/navigation.html       |   6 +-
 .../function/out/html/root/[jvm root]/fn.html      |  34 ---
 .../function/out/html/root/[jvm root]/index.html   |  50 ----
 .../function/out/html/root/[main root]/fn.html     |  34 +++
 .../function/out/html/root/[main root]/index.html  |  50 ++++
 .../expect/function/out/html/root/index.html       |   4 +-
 .../expect/function/out/html/root/package-list     |   4 +-
 .../out/html/navigation.html                       |  10 +-
 .../out/html/root/[jvm root]/-fancy/-init-.html    |  32 ---
 .../out/html/root/[jvm root]/-fancy/equals.html    |  32 ---
 .../out/html/root/[jvm root]/-fancy/hash-code.html |  32 ---
 .../out/html/root/[jvm root]/-fancy/index.html     |  83 -------
 .../out/html/root/[jvm root]/-fancy/to-string.html |  32 ---
 .../out/html/root/[jvm root]/function.html         |  32 ---
 .../out/html/root/[jvm root]/index.html            |  69 ------
 .../out/html/root/[main root]/-fancy/-init-.html   |  32 +++
 .../out/html/root/[main root]/-fancy/equals.html   |  32 +++
 .../html/root/[main root]/-fancy/hash-code.html    |  32 +++
 .../out/html/root/[main root]/-fancy/index.html    |  83 +++++++
 .../html/root/[main root]/-fancy/to-string.html    |  32 +++
 .../out/html/root/[main root]/function.html        |  32 +++
 .../out/html/root/[main root]/index.html           |  69 ++++++
 .../out/html/root/index.html                       |   4 +-
 .../out/html/root/package-list                     |  10 +-
 .../out/html/navigation.html                       |   6 +-
 .../out/html/root/[jvm root]/f.html                |  32 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/f.html               |  32 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../out/html/root/index.html                       |   4 +-
 .../out/html/root/package-list                     |   4 +-
 .../out/html/navigation.html                       |   6 +-
 .../out/html/root/[jvm root]/function.html         |  32 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/function.html        |  32 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../out/html/root/index.html                       |   4 +-
 .../out/html/root/package-list                     |   4 +-
 .../out/html/navigation.html                       |   6 +-
 .../out/html/root/[jvm root]/f.html                |  32 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/f.html               |  32 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../out/html/root/index.html                       |   4 +-
 .../out/html/root/package-list                     |   4 +-
 .../functionWithParams/out/html/navigation.html    |   6 +-
 .../out/html/root/[jvm root]/function.html         |  34 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/function.html        |  34 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../functionWithParams/out/html/root/index.html    |   4 +-
 .../functionWithParams/out/html/root/package-list  |   4 +-
 .../functionWithReceiver/out/html/navigation.html  |   6 +-
 .../out/html/root/[jvm root]/fn.html               |  40 ----
 .../out/html/root/[jvm root]/index.html            |  66 ------
 .../out/html/root/[main root]/fn.html              |  40 ++++
 .../out/html/root/[main root]/index.html           |  66 ++++++
 .../functionWithReceiver/out/html/root/index.html  |   4 +-
 .../out/html/root/package-list                     |   6 +-
 .../genericFunction/out/html/navigation.html       |   6 +-
 .../out/html/root/[jvm root]/generic.html          |  34 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/generic.html         |  34 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../genericFunction/out/html/root/index.html       |   4 +-
 .../genericFunction/out/html/root/package-list     |   4 +-
 .../out/html/navigation.html                       |   6 +-
 .../out/html/root/[jvm root]/generic.html          |  34 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/generic.html         |  34 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../out/html/root/index.html                       |   4 +-
 .../out/html/root/package-list                     |   4 +-
 .../expect/inlineFunction/out/html/navigation.html |   6 +-
 .../inlineFunction/out/html/root/[jvm root]/f.html |  32 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/f.html               |  32 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../expect/inlineFunction/out/html/root/index.html |   4 +-
 .../inlineFunction/out/html/root/package-list      |   4 +-
 .../inlineSuspendFunction/out/html/navigation.html |   6 +-
 .../out/html/root/[jvm root]/f.html                |  32 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/f.html               |  32 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../inlineSuspendFunction/out/html/root/index.html |   4 +-
 .../out/html/root/package-list                     |   4 +-
 .../expect/signatureTest/out/html/root/index.html  |   2 +-
 .../out/html/root/signatureTest/index.html         |   8 +-
 .../out/html/root/signatureTest/test.html          |   2 +-
 .../out/html/root/signatureTest/test2.html         |   2 +-
 .../expect/sinceKotlin/out/html/navigation.html    |   6 +-
 .../html/root/[jvm root]/available-since1.1.html   |  34 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../html/root/[main root]/available-since1.1.html  |  34 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../expect/sinceKotlin/out/html/root/index.html    |   4 +-
 .../expect/sinceKotlin/out/html/root/package-list  |   4 +-
 .../suspendFunction/out/html/navigation.html       |   6 +-
 .../out/html/root/[jvm root]/f.html                |  32 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/f.html               |  32 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../suspendFunction/out/html/root/index.html       |   4 +-
 .../suspendFunction/out/html/root/package-list     |   4 +-
 .../suspendInlineFunction/out/html/navigation.html |   6 +-
 .../out/html/root/[jvm root]/f.html                |  32 ---
 .../out/html/root/[jvm root]/index.html            |  50 ----
 .../out/html/root/[main root]/f.html               |  32 +++
 .../out/html/root/[main root]/index.html           |  50 ++++
 .../suspendInlineFunction/out/html/root/index.html |   4 +-
 .../out/html/root/package-list                     |   4 +-
 plugins/gfm/src/main/kotlin/GfmPlugin.kt           |  11 +-
 .../kotlin/converters/KotlinToJavaConverter.kt     |  86 +++----
 .../kotlin/signatures/JavaSignatureProvider.kt     |   4 +-
 runners/cli/src/main/kotlin/cli/main.kt            |  11 +
 .../dokka/gradle/ConfigurationExtractor.kt         | 144 ++++++------
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt |  47 ++--
 .../dokka/gradle/configurationImplementations.kt   |   2 +
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |   4 +-
 .../kotlin/org/jetbrains/dokka/gradle/utils.kt     |  14 +-
 runners/maven-plugin/src/main/kotlin/DokkaMojo.kt  |   7 +-
 .../src/main/kotlin/testApi/context/MockContext.kt |  12 +-
 .../testApi/testRunner/DokkaTestGenerator.kt       |  11 +-
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |  10 +-
 193 files changed, 3010 insertions(+), 3003 deletions(-)
 create mode 100644 core/src/main/kotlin/model/SourceSetData.kt
 delete mode 100644 plugins/base/src/test/kotlin/renderers/html/PlatformDependentHintTest.kt
 create mode 100644 plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[jvm root]/f.html
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[main root]/f.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[main root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunction/out/html/scripts/pages.js
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/-init-.html
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/equals.html
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/hash-code.html
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/to-string.html
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/f.html
 delete mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/-init-.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/equals.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/hash-code.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/index.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/to-string.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/f.html
 create mode 100644 plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/function/out/html/root/[jvm root]/fn.html
 delete mode 100644 plugins/base/src/test/resources/expect/function/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/function/out/html/root/[main root]/fn.html
 create mode 100644 plugins/base/src/test/resources/expect/function/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/-init-.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/equals.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/hash-code.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/to-string.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/function.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/-init-.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/equals.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/hash-code.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/index.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/to-string.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/function.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[jvm root]/f.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[main root]/f.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[jvm root]/function.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[main root]/function.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[jvm root]/f.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[main root]/f.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[jvm root]/function.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[main root]/function.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[jvm root]/fn.html
 delete mode 100644 plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[main root]/fn.html
 create mode 100644 plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/genericFunction/out/html/root/[jvm root]/generic.html
 delete mode 100644 plugins/base/src/test/resources/expect/genericFunction/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/genericFunction/out/html/root/[main root]/generic.html
 create mode 100644 plugins/base/src/test/resources/expect/genericFunction/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[jvm root]/generic.html
 delete mode 100644 plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[main root]/generic.html
 create mode 100644 plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[jvm root]/f.html
 delete mode 100644 plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[main root]/f.html
 create mode 100644 plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[jvm root]/f.html
 delete mode 100644 plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[main root]/f.html
 create mode 100644 plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[jvm root]/available-since1.1.html
 delete mode 100644 plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[main root]/available-since1.1.html
 create mode 100644 plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[jvm root]/f.html
 delete mode 100644 plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[main root]/f.html
 create mode 100644 plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[main root]/index.html
 delete mode 100644 plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[jvm root]/f.html
 delete mode 100644 plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[jvm root]/index.html
 create mode 100644 plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[main root]/f.html
 create mode 100644 plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[main root]/index.html

(limited to 'core/src/main/kotlin/plugability')

diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index 7ee14d19..a7e03ba2 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -16,8 +16,14 @@
       <module name="android-gradle-plugin_test" target="1.8" />
       <module name="ant_main" target="1.8" />
       <module name="ant_test" target="1.8" />
+      <module name="base.dokka.plugins.base.main" target="1.8" />
+      <module name="base.dokka.plugins.base.test" target="1.8" />
+      <module name="blazejkardys.Workspace.dokka.buildSrc.main" target="1.8" />
+      <module name="blazejkardys.Workspace.dokka.buildSrc.test" target="1.8" />
       <module name="buildSrc_main" target="1.8" />
       <module name="buildSrc_test" target="1.8" />
+      <module name="cli.dokka.runners.cli.main" target="1.8" />
+      <module name="cli.dokka.runners.cli.test" target="1.8" />
       <module name="cli_main" target="1.8" />
       <module name="cli_test" target="1.8" />
       <module name="core_main" target="1.8" />
@@ -78,14 +84,24 @@
       <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.dokka.integration-tests.gradle-integration-tests.main" target="1.8" />
+      <module name="gradle-integration-tests.dokka.integration-tests.gradle-integration-tests.test" target="1.8" />
       <module name="gradle-integration-tests.org.jetbrains.dokka.gradle-integration-tests.main" target="1.8" />
       <module name="gradle-integration-tests.org.jetbrains.dokka.gradle-integration-tests.test" target="1.8" />
       <module name="gradle-integration-tests_main" target="1.8" />
       <module name="gradle-integration-tests_test" target="1.8" />
+      <module name="gradle-plugin.dokka.runners.gradle-plugin.main" target="1.8" />
+      <module name="gradle-plugin.dokka.runners.gradle-plugin.test" target="1.8" />
       <module name="gradle-plugin_main" target="1.8" />
       <module name="gradle-plugin_test" target="1.8" />
       <module name="integration_main" target="1.8" />
       <module name="integration_test" target="1.8" />
+      <module name="kotlin-as-java.dokka.plugins.kotlin-as-java.main" target="1.8" />
+      <module name="kotlin-as-java.dokka.plugins.kotlin-as-java.test" target="1.8" />
+      <module name="mathjax.dokka.plugins.mathjax.main" target="1.8" />
+      <module name="mathjax.dokka.plugins.mathjax.test" target="1.8" />
+      <module name="maven-plugin.dokka.runners.maven-plugin.main" target="1.8" />
+      <module name="maven-plugin.dokka.runners.maven-plugin.test" target="1.8" />
       <module name="maven-plugin_main" target="1.8" />
       <module name="maven-plugin_test" target="1.8" />
       <module name="org.jetbrains.dokka.android-gradle-plugin.main" target="1.8" />
@@ -101,6 +117,8 @@
       <module name="org.jetbrains.dokka.coreDependencies.main" target="1.8" />
       <module name="org.jetbrains.dokka.coreDependencies.test" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.core.main" target="1.8" />
+      <module name="org.jetbrains.dokka.dokka.core.search-component.main" target="1.8" />
+      <module name="org.jetbrains.dokka.dokka.core.search-component.test" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.core.test" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.coreDependencies.main" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.coreDependencies.test" target="1.8" />
@@ -110,6 +128,10 @@
       <module name="org.jetbrains.dokka.dokka.integration-tests.test" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.plugins.base.main" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.plugins.base.test" target="1.8" />
+      <module name="org.jetbrains.dokka.dokka.plugins.gfm.main" target="1.8" />
+      <module name="org.jetbrains.dokka.dokka.plugins.gfm.test" target="1.8" />
+      <module name="org.jetbrains.dokka.dokka.plugins.jekyll.main" target="1.8" />
+      <module name="org.jetbrains.dokka.dokka.plugins.jekyll.test" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.plugins.kotlin-as-java.main" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.plugins.kotlin-as-java.test" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.plugins.main" target="1.8" />
@@ -126,6 +148,8 @@
       <module name="org.jetbrains.dokka.dokka.runners.test" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.search-component.main" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.search-component.test" target="1.8" />
+      <module name="org.jetbrains.dokka.dokka.test-tools.main" target="1.8" />
+      <module name="org.jetbrains.dokka.dokka.test-tools.test" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.testApi.main" target="1.8" />
       <module name="org.jetbrains.dokka.dokka.testApi.test" target="1.8" />
       <module name="org.jetbrains.dokka.fatjar.main" target="1.8" />
@@ -150,6 +174,18 @@
       <module name="org.jetbrains.dokka.xml.test" target="1.8" />
       <module name="Workspace.dokka.buildSrc.main" target="1.8" />
       <module name="Workspace.dokka.buildSrc.test" target="1.8" />
+      <module name="Workspace.dokka.core.main" target="1.8" />
+      <module name="Workspace.dokka.core.test" target="1.8" />
+      <module name="Workspace.dokka.coreDependencies.main" target="1.8" />
+      <module name="Workspace.dokka.coreDependencies.test" target="1.8" />
+      <module name="Workspace.dokka.integration-tests.main" target="1.8" />
+      <module name="Workspace.dokka.integration-tests.test" target="1.8" />
+      <module name="Workspace.dokka.plugins.main" target="1.8" />
+      <module name="Workspace.dokka.plugins.test" target="1.8" />
+      <module name="Workspace.dokka.runners.main" target="1.8" />
+      <module name="Workspace.dokka.runners.test" target="1.8" />
+      <module name="Workspace.dokka.testApi.main" target="1.8" />
+      <module name="Workspace.dokka.testApi.test" target="1.8" />
     </bytecodeTargetLevel>
   </component>
 </project>
\ No newline at end of file
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 053b4cb6..6e62c033 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,23 +1,20 @@
 package org.jetbrains.dokka
 
-import com.intellij.openapi.vfs.VirtualFileManager
-import com.intellij.psi.PsiJavaFile
-import com.intellij.psi.PsiManager
 import org.jetbrains.dokka.analysis.AnalysisEnvironment
 import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.model.SourceSetCache
+import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 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.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 
@@ -31,13 +28,14 @@ class DokkaGenerator(
 ) {
     fun generate() = timed {
         report("Setting up analysis environments")
-        val platforms: Map<PlatformData, EnvironmentAndFacade> = setUpAnalysis(configuration)
+        val sourceSetsCache = SourceSetCache()
+        val sourceSets: Map<SourceSetData, EnvironmentAndFacade> = setUpAnalysis(configuration, sourceSetsCache)
 
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, platforms)
+        val context = initializePlugins(configuration, logger, sourceSets, sourceSetsCache)
 
         report("Creating documentation models")
-        val modulesFromPlatforms = createDocumentationModels(platforms, context)
+        val modulesFromPlatforms = createDocumentationModels(sourceSets, context)
 
         report("Transforming documentation model before merging")
         val transformedDocumentationBeforeMerge = transformDocumentationModelBeforeMerge(modulesFromPlatforms, context)
@@ -62,27 +60,31 @@ class DokkaGenerator(
         logger.report()
     }.dump("\n\n === TIME MEASUREMENT ===\n")
 
-    fun setUpAnalysis(configuration: DokkaConfiguration): Map<PlatformData, EnvironmentAndFacade> =
+    fun setUpAnalysis(
+        configuration: DokkaConfiguration,
+        sourceSetsCache: SourceSetCache
+    ): Map<SourceSetData, EnvironmentAndFacade> =
         configuration.passesConfigurations.map {
-            it.platformData to createEnvironmentAndFacade(it)
+            sourceSetsCache.getSourceSet(it) to createEnvironmentAndFacade(it)
         }.toMap()
 
     fun initializePlugins(
         configuration: DokkaConfiguration,
         logger: DokkaLogger,
-        platforms: Map<PlatformData, EnvironmentAndFacade>,
+        sourceSets: Map<SourceSetData, EnvironmentAndFacade>,
+        sourceSetsCache: SourceSetCache,
         pluginOverrides: List<DokkaPlugin> = emptyList()
-    ) = DokkaContext.create(configuration, logger, platforms, pluginOverrides)
+    ) = DokkaContext.create(configuration, logger, sourceSets, sourceSetsCache, pluginOverrides)
 
     fun createDocumentationModels(
-        platforms: Map<PlatformData, EnvironmentAndFacade>,
+        platforms: Map<SourceSetData, EnvironmentAndFacade>,
         context: DokkaContext
     ) = platforms.flatMap { (pdata, _) -> translateSources(pdata, context) }
 
     fun transformDocumentationModelBeforeMerge(
         modulesFromPlatforms: List<DModule>,
         context: DokkaContext
-    ) = context[CoreExtensions.preMergeDocumentableTransformer].fold(modulesFromPlatforms) { acc, t -> t(acc, context) }
+    ) = context[CoreExtensions.preMergeDocumentableTransformer].fold(modulesFromPlatforms) { acc, t -> t(acc) }
 
     fun mergeDocumentationModels(
         modulesFromPlatforms: List<DModule>,
@@ -119,7 +121,7 @@ class DokkaGenerator(
             }
             pass.classpath.forEach { addClasspath(File(it)) }
 
-            addSources(pass.sourceRoots.map { it.path })
+            addSources((pass.sourceRoots +  pass.dependentSourceRoots).map { it.path })
 
             loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
 
@@ -128,7 +130,7 @@ class DokkaGenerator(
             EnvironmentAndFacade(environment, facade)
         }
 
-    private fun translateSources(platformData: PlatformData, context: DokkaContext) =
+    private fun translateSources(platformData: SourceSetData, context: DokkaContext) =
         context[CoreExtensions.sourceToDocumentableTranslator].map {
             it.invoke(platformData, context)
         }
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index 34671c4e..88924924 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.pages.PlatformData
 import java.io.File
 import java.net.URL
 
@@ -37,8 +36,10 @@ interface DokkaConfiguration {
 
     interface PassConfiguration {
         val moduleName: String
+        val sourceSetName: String
         val classpath: List<String>
         val sourceRoots: List<SourceRoot>
+        val dependentSourceRoots: List<SourceRoot>
         val samples: List<String>
         val includes: List<String>
         val includeNonPublic: Boolean
@@ -59,9 +60,6 @@ interface DokkaConfiguration {
         val analysisPlatform: Platform
         val targets: List<String>
         val sinceKotlin: String?
-
-        val platformData: PlatformData
-        get() = PlatformData(moduleName, analysisPlatform, targets)
     }
 
     interface SourceRoot {
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index ae674ea1..08f70b45 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -16,8 +16,10 @@ data class DokkaConfigurationImpl(
 
 data class PassConfigurationImpl (
     override val moduleName: String,
+    override val sourceSetName: String,
     override val classpath: List<String>,
     override val sourceRoots: List<SourceRootImpl>,
+    override val dependentSourceRoots: List<SourceRootImpl>,
     override val samples: List<String>,
     override val includes: List<String>,
     override val includeNonPublic: Boolean,
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index 313f4cd4..85487725 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -1,11 +1,12 @@
 package org.jetbrains.dokka.model
 
 import com.intellij.psi.PsiNamedElement
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.model.properties.WithExtraProperties
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.load.kotlin.toSourceElement
 
@@ -13,8 +14,9 @@ abstract class Documentable {
     abstract val name: String?
     abstract val dri: DRI
     abstract val children: List<Documentable>
-    abstract val documentation: PlatformDependent<DocumentationNode>
-    abstract val platformData: List<PlatformData>
+    abstract val documentation: SourceSetDependent<DocumentationNode>
+    abstract val sourceSets: List<SourceSetData>
+    abstract val expectPresentInSet: SourceSetData?
 
     override fun toString(): String =
         "${javaClass.simpleName}($dri)"
@@ -25,45 +27,10 @@ abstract class Documentable {
     override fun hashCode() = dri.hashCode()
 }
 
-data class PlatformDependent<out T>(
-    val map: Map<PlatformData, T>,
-    val expect: T? = null
-) : Map<PlatformData, T> by map {
-    val prevalentValue: T?
-        get() = map.values.distinct().singleOrNull()
-
-    val allValues: Sequence<T> = sequence {
-        expect?.also { yield(it) }
-        yieldAll(map.values)
-    }
-
-    val allEntries: Sequence<Pair<PlatformData?, T>> = sequence {
-        expect?.also { yield(null to it) }
-        map.forEach { (k, v) -> yield(k to v) }
-    }
-
-    fun getOrExpect(platform: PlatformData): T? = map[platform] ?: expect
-
-    companion object {
-        fun <T> empty(): PlatformDependent<T> = PlatformDependent(emptyMap())
-
-        fun <T> from(platformData: PlatformData, element: T) = PlatformDependent(mapOf(platformData to element))
-
-        @Suppress("UNCHECKED_CAST")
-        fun <T> from(pairs: Iterable<Pair<PlatformData?, T>>) =
-            PlatformDependent(
-                pairs.filter { it.first != null }.toMap() as Map<PlatformData, T>,
-                pairs.firstOrNull { it.first == null }?.second
-            )
-
-        fun <T> from(vararg pairs: Pair<PlatformData?, T>) = from(pairs.asIterable())
-
-        fun <T> expectFrom(element: T) = PlatformDependent(map = emptyMap(), expect = element)
-    }
-}
+typealias SourceSetDependent<T> = Map<SourceSetData, T>
 
 interface WithExpectActual {
-    val sources: PlatformDependent<DocumentableSource>
+    val sources: SourceSetDependent<DocumentableSource>
 }
 
 interface WithScope {
@@ -73,7 +40,7 @@ interface WithScope {
 }
 
 interface WithVisibility {
-    val visibility: PlatformDependent<Visibility>
+    val visibility: SourceSetDependent<Visibility>
 }
 
 interface WithType {
@@ -81,7 +48,7 @@ interface WithType {
 }
 
 interface WithAbstraction {
-    val modifier: PlatformDependent<Modifier>
+    val modifier: SourceSetDependent<Modifier>
 }
 
 sealed class Modifier(val name: String)
@@ -112,7 +79,7 @@ interface WithGenerics {
 }
 
 interface WithSupertypes {
-    val supertypes: PlatformDependent<List<DRI>>
+    val supertypes: SourceSetDependent<List<DRI>>
 }
 
 interface Callable : WithVisibility, WithType, WithAbstraction, WithExpectActual {
@@ -124,8 +91,9 @@ sealed class DClasslike : Documentable(), WithScope, WithVisibility, WithExpectA
 data class DModule(
     override val name: String,
     val packages: List<DPackage>,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val platformData: List<PlatformData>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData? = null,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DModule> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DModule> {
     override val dri: DRI = DRI.topLevel
@@ -141,8 +109,9 @@ data class DPackage(
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
     val typealiases: List<DTypeAlias>,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val platformData: List<PlatformData>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData? = null,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DPackage> = PropertyContainer.empty()
 ) : Documentable(), WithScope, WithExtraProperties<DPackage> {
     override val name = dri.packageName.orEmpty()
@@ -159,14 +128,15 @@ data class DClass(
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
-    override val sources: PlatformDependent<DocumentableSource>,
-    override val visibility: PlatformDependent<Visibility>,
+    override val sources: SourceSetDependent<DocumentableSource>,
+    override val visibility: SourceSetDependent<Visibility>,
     override val companion: DObject?,
     override val generics: List<DTypeParameter>,
-    override val supertypes: PlatformDependent<List<DRI>>,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val modifier: PlatformDependent<Modifier>,
-    override val platformData: List<PlatformData>,
+    override val supertypes: SourceSetDependent<List<DRI>>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
+    override val modifier: SourceSetDependent<Modifier>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DClass> = PropertyContainer.empty()
 ) : DClasslike(), WithAbstraction, WithCompanion, WithConstructors, WithGenerics, WithSupertypes,
     WithExtraProperties<DClass> {
@@ -181,16 +151,17 @@ data class DEnum(
     override val dri: DRI,
     override val name: String,
     val entries: List<DEnumEntry>,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val sources: PlatformDependent<DocumentableSource>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
+    override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
-    override val visibility: PlatformDependent<Visibility>,
+    override val visibility: SourceSetDependent<Visibility>,
     override val companion: DObject?,
     override val constructors: List<DFunction>,
-    override val supertypes: PlatformDependent<List<DRI>>,
-    override val platformData: List<PlatformData>,
+    override val supertypes: SourceSetDependent<List<DRI>>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DEnum> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithConstructors, WithSupertypes, WithExtraProperties<DEnum> {
     override val children: List<Documentable>
@@ -202,11 +173,12 @@ data class DEnum(
 data class DEnumEntry(
     override val dri: DRI,
     override val name: String,
-    override val documentation: PlatformDependent<DocumentationNode>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
-    override val platformData: List<PlatformData>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DEnumEntry> = PropertyContainer.empty()
 ) : Documentable(), WithScope, WithExtraProperties<DEnumEntry> {
     override val children: List<Documentable>
@@ -220,14 +192,15 @@ data class DFunction(
     override val name: String,
     val isConstructor: Boolean,
     val parameters: List<DParameter>,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val sources: PlatformDependent<DocumentableSource>,
-    override val visibility: PlatformDependent<Visibility>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
+    override val sources: SourceSetDependent<DocumentableSource>,
+    override val visibility: SourceSetDependent<Visibility>,
     override val type: Bound,
     override val generics: List<DTypeParameter>,
     override val receiver: DParameter?,
-    override val modifier: PlatformDependent<Modifier>,
-    override val platformData: List<PlatformData>,
+    override val modifier: SourceSetDependent<Modifier>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DFunction> = PropertyContainer.empty()
 ) : Documentable(), Callable, WithGenerics, WithExtraProperties<DFunction> {
     override val children: List<Documentable>
@@ -239,16 +212,17 @@ data class DFunction(
 data class DInterface(
     override val dri: DRI,
     override val name: String,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val sources: PlatformDependent<DocumentableSource>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
+    override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
-    override val visibility: PlatformDependent<Visibility>,
+    override val visibility: SourceSetDependent<Visibility>,
     override val companion: DObject?,
     override val generics: List<DTypeParameter>,
-    override val supertypes: PlatformDependent<List<DRI>>,
-    override val platformData: List<PlatformData>,
+    override val supertypes: SourceSetDependent<List<DRI>>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DInterface> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithGenerics, WithSupertypes, WithExtraProperties<DInterface> {
     override val children: List<Documentable>
@@ -260,14 +234,15 @@ data class DInterface(
 data class DObject(
     override val name: String?,
     override val dri: DRI,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val sources: PlatformDependent<DocumentableSource>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
+    override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
-    override val visibility: PlatformDependent<Visibility>,
-    override val supertypes: PlatformDependent<List<DRI>>,
-    override val platformData: List<PlatformData>,
+    override val visibility: SourceSetDependent<Visibility>,
+    override val supertypes: SourceSetDependent<List<DRI>>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DObject> = PropertyContainer.empty()
 ) : DClasslike(), WithSupertypes, WithExtraProperties<DObject> {
     override val children: List<Documentable>
@@ -279,15 +254,16 @@ data class DObject(
 data class DAnnotation(
     override val name: String,
     override val dri: DRI,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val sources: PlatformDependent<DocumentableSource>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
+    override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
-    override val visibility: PlatformDependent<Visibility>,
+    override val visibility: SourceSetDependent<Visibility>,
     override val companion: DObject?,
     override val constructors: List<DFunction>,
-    override val platformData: List<PlatformData>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DAnnotation> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithConstructors, WithExtraProperties<DAnnotation> {
     override val children: List<Documentable>
@@ -299,15 +275,16 @@ data class DAnnotation(
 data class DProperty(
     override val dri: DRI,
     override val name: String,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val sources: PlatformDependent<DocumentableSource>,
-    override val visibility: PlatformDependent<Visibility>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
+    override val sources: SourceSetDependent<DocumentableSource>,
+    override val visibility: SourceSetDependent<Visibility>,
     override val type: Bound,
     override val receiver: DParameter?,
     val setter: DFunction?,
     val getter: DFunction?,
-    override val modifier: PlatformDependent<Modifier>,
-    override val platformData: List<PlatformData>,
+    override val modifier: SourceSetDependent<Modifier>,
+    override val sourceSets: List<SourceSetData>,
     override val generics: List<DTypeParameter>,
     override val extra: PropertyContainer<DProperty> = PropertyContainer.empty()
 ) : Documentable(), Callable, WithExtraProperties<DProperty>, WithGenerics {
@@ -321,9 +298,10 @@ data class DProperty(
 data class DParameter(
     override val dri: DRI,
     override val name: String?,
-    override val documentation: PlatformDependent<DocumentationNode>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
     val type: Bound,
-    override val platformData: List<PlatformData>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DParameter> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DParameter> {
     override val children: List<Nothing>
@@ -335,9 +313,10 @@ data class DParameter(
 data class DTypeParameter(
     override val dri: DRI,
     override val name: String,
-    override val documentation: PlatformDependent<DocumentationNode>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
     val bounds: List<Bound>,
-    override val platformData: List<PlatformData>,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DTypeParameter> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DTypeParameter> {
     override val children: List<Nothing>
@@ -350,10 +329,11 @@ data class DTypeAlias(
     override val dri: DRI,
     override val name: String,
     override val type: Bound,
-    val underlyingType: PlatformDependent<Bound>,
-    override val visibility: PlatformDependent<Visibility>,
-    override val documentation: PlatformDependent<DocumentationNode>,
-    override val platformData: List<PlatformData>,
+    val underlyingType: SourceSetDependent<Bound>,
+    override val visibility: SourceSetDependent<Visibility>,
+    override val documentation: SourceSetDependent<DocumentationNode>,
+    override val expectPresentInSet: SourceSetData?,
+    override val sourceSets: List<SourceSetData>,
     override val extra: PropertyContainer<DTypeAlias> = PropertyContainer.empty()
 ) : Documentable(), WithType, WithVisibility, WithExtraProperties<DTypeAlias> {
     override val children: List<Nothing>
@@ -417,7 +397,7 @@ sealed class JavaVisibility(name: String) : Visibility(name) {
     object Default : JavaVisibility("")
 }
 
-fun <T> PlatformDependent<T>?.orEmpty(): PlatformDependent<T> = this ?: PlatformDependent.empty()
+fun <T> SourceSetDependent<T>?.orEmpty(): SourceSetDependent<T> = this ?: emptyMap()
 
 interface DocumentableSource {
     val path: String
@@ -429,4 +409,4 @@ class DescriptorDocumentableSource(val descriptor: DeclarationDescriptor) : Docu
 
 class PsiDocumentableSource(val psi: PsiNamedElement) : DocumentableSource {
     override val path = psi.containingFile.virtualFile.path
-}
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/SourceSetData.kt b/core/src/main/kotlin/model/SourceSetData.kt
new file mode 100644
index 00000000..8f67f272
--- /dev/null
+++ b/core/src/main/kotlin/model/SourceSetData.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.dokka.model
+
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.plugability.DokkaContext
+
+data class SourceSetData(
+    val moduleName: String,
+    val sourceSetName: String,
+    val platform: Platform,
+    val sourceRoots: List<DokkaConfiguration.SourceRoot> = emptyList()
+)
+
+class SourceSetCache {
+    private val sourceSets = HashMap<String, SourceSetData>()
+
+    fun getSourceSet(pass: DokkaConfiguration.PassConfiguration) =
+        sourceSets.getOrPut("${pass.moduleName}/${pass.sourceSetName}",
+            { SourceSetData(pass.moduleName, pass.sourceSetName, pass.analysisPlatform, pass.sourceRoots) }
+        )
+}
+
+fun DokkaContext.sourceSet(pass: DokkaConfiguration.PassConfiguration) : SourceSetData = sourceSetCache.getSourceSet(pass)
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/aditionalExtras.kt b/core/src/main/kotlin/model/aditionalExtras.kt
index 58209939..27ad8a55 100644
--- a/core/src/main/kotlin/model/aditionalExtras.kt
+++ b/core/src/main/kotlin/model/aditionalExtras.kt
@@ -41,13 +41,13 @@ object PrimaryConstructorExtra : ExtraProperty<DFunction>, ExtraProperty.Key<DFu
     override val key: ExtraProperty.Key<DFunction, *> = this
 }
 
-data class ActualTypealias(val underlyingType: PlatformDependent<Bound>) : ExtraProperty<DClasslike> {
+data class ActualTypealias(val underlyingType: SourceSetDependent<Bound>) : ExtraProperty<DClasslike> {
     companion object : ExtraProperty.Key<DClasslike, ActualTypealias> {
         override fun mergeStrategyFor(
             left: ActualTypealias,
             right: ActualTypealias
         ) =
-            MergeStrategy.Replace(ActualTypealias(PlatformDependent(left.underlyingType + right.underlyingType)))
+            MergeStrategy.Replace(ActualTypealias(left.underlyingType + right.underlyingType))
     }
 
     override val key: ExtraProperty.Key<DClasslike, ActualTypealias> = ActualTypealias
diff --git a/core/src/main/kotlin/model/documentableUtils.kt b/core/src/main/kotlin/model/documentableUtils.kt
index 7f946344..b09260ee 100644
--- a/core/src/main/kotlin/model/documentableUtils.kt
+++ b/core/src/main/kotlin/model/documentableUtils.kt
@@ -1,21 +1,18 @@
 package org.jetbrains.dokka.model
 
-import org.jetbrains.dokka.pages.PlatformData
+fun <T> SourceSetDependent<T>.filtered(platformDataList: List<SourceSetData>) = filter { it.key in platformDataList }
+fun SourceSetData?.filtered(platformDataList: List<SourceSetData>) = takeIf { this in platformDataList }
 
-fun <T> PlatformDependent<T>.filtered(platformDataList: List<PlatformData>) = PlatformDependent(
-    map.filter { it.key in platformDataList },
-    expect
-)
-
-fun DTypeParameter.filter(filteredData: List<PlatformData>) =
-    if (filteredData.containsAll(platformData)) this
+fun DTypeParameter.filter(filteredData: List<SourceSetData>) =
+    if (filteredData.containsAll(sourceSets)) this
     else {
-        val intersection = filteredData.intersect(platformData).toList()
+        val intersection = filteredData.intersect(sourceSets).toList()
         if (intersection.isEmpty()) null
         else DTypeParameter(
             dri,
             name,
             documentation.filtered(intersection),
+            expectPresentInSet?.takeIf { intersection.contains(expectPresentInSet) },
             bounds,
             intersection,
             extra
diff --git a/core/src/main/kotlin/pages/ContentNodes.kt b/core/src/main/kotlin/pages/ContentNodes.kt
index 26bcdf77..bb669199 100644
--- a/core/src/main/kotlin/pages/ContentNodes.kt
+++ b/core/src/main/kotlin/pages/ContentNodes.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.dokka.pages
 
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.model.properties.WithExtraProperties
 
@@ -10,7 +11,7 @@ data class DCI(val dri: Set<DRI>, val kind: Kind) {
 
 interface ContentNode : WithExtraProperties<ContentNode> {
     val dci: DCI
-    val platforms: Set<PlatformData>
+    val sourceSets: Set<SourceSetData>
     val style: Set<Style>
 }
 
@@ -18,7 +19,7 @@ interface ContentNode : WithExtraProperties<ContentNode> {
 data class ContentText(
     val text: String,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentNode {
@@ -27,7 +28,7 @@ data class ContentText(
 
 // TODO: Remove
 data class ContentBreakLine(
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val dci: DCI = DCI(emptySet(), ContentKind.Empty),
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
@@ -40,11 +41,11 @@ data class ContentHeader(
     override val children: List<ContentNode>,
     val level: Int,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
-    constructor(level: Int, c: ContentComposite) : this(c.children, level, c.dci, c.platforms, c.style, c.extra)
+    constructor(level: Int, c: ContentComposite) : this(c.children, level, c.dci, c.sourceSets, c.style, c.extra)
 
     override fun withNewExtras(newExtras: PropertyContainer<ContentNode>): ContentHeader = copy(extra = newExtras)
 }
@@ -54,7 +55,7 @@ data class ContentCode(
     override val children: List<ContentNode>,
     val language: String,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -69,7 +70,7 @@ data class ContentDRILink(
     override val children: List<ContentNode>,
     val address: DRI,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -81,7 +82,7 @@ data class ContentResolvedLink(
     override val children: List<ContentNode>,
     val address: String,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -95,7 +96,7 @@ data class ContentEmbeddedResource(
     val address: String,
     val altText: String?,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -113,7 +114,7 @@ data class ContentTable(
     val header: List<ContentGroup>,
     override val children: List<ContentGroup>,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -125,7 +126,7 @@ data class ContentList(
     override val children: List<ContentNode>,
     val ordered: Boolean,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -136,7 +137,7 @@ data class ContentList(
 data class ContentGroup(
     override val children: List<ContentNode>,
     override val dci: DCI,
-    override val platforms: Set<PlatformData>,
+    override val sourceSets: Set<SourceSetData>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -145,7 +146,7 @@ data class ContentGroup(
 
 data class PlatformHintedContent(
     val inner: ContentNode,
-    override val platforms: Set<PlatformData>
+    override val sourceSets: Set<SourceSetData>
 ) : ContentComposite {
     override val children = listOf(inner)
 
@@ -171,7 +172,7 @@ interface Kind
 enum class ContentKind : Kind {
 
     Comment, Constructors, Functions, Parameters, Properties, Classlikes, Packages, Symbol, Sample, Main, BriefComment,
-    Empty, Source, TypeAliases, Cover, Inheritors, PlatformDependantHint;
+    Empty, Source, TypeAliases, Cover, Inheritors, SourceSetDependantHint;
 
     companion object {
         private val platformTagged =
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index 244d951e..32b2846e 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.pages
 
+import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.model.Documentable
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.links.DRI
@@ -151,10 +152,6 @@ class MemberPageNode(
         else MemberPageNode(name, content, dri, documentable, children, embeddedResources)
 }
 
-data class PlatformData(val name: String, val platformType: Platform, val targets: List<String>) {
-    override fun toString() = targets.toString()
-}
-
 fun PageNode.dfs(predicate: (PageNode) -> Boolean): PageNode? = if (predicate(this)) {
     this
 } else {
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index cefcd286..692803dd 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -2,7 +2,8 @@ package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.EnvironmentAndFacade
-import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.model.SourceSetCache
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.utilities.DokkaLogger
 import java.io.File
 import java.net.URLClassLoader
@@ -19,9 +20,10 @@ interface DokkaContext {
 
     fun <T, E> single(point: E): T where T : Any, E : ExtensionPoint<T>
 
+    val sourceSetCache: SourceSetCache
     val logger: DokkaLogger
     val configuration: DokkaConfiguration
-    val platforms: Map<PlatformData, EnvironmentAndFacade>
+    val platforms: Map<SourceSetData, EnvironmentAndFacade>
     val unusedPoints: Collection<ExtensionPoint<*>>
 
 
@@ -29,10 +31,11 @@ interface DokkaContext {
         fun create(
             configuration: DokkaConfiguration,
             logger: DokkaLogger,
-            platforms: Map<PlatformData, EnvironmentAndFacade>,
+            sourceSets: Map<SourceSetData, EnvironmentAndFacade>,
+            sourceSetsCache: SourceSetCache,
             pluginOverrides: List<DokkaPlugin>
         ): DokkaContext =
-            DokkaContextConfigurationImpl(logger, configuration, platforms).apply {
+            DokkaContextConfigurationImpl(logger, configuration, sourceSets, sourceSetsCache).apply {
                 // File(it.path) is a workaround for an incorrect filesystem in a File instance returned by Gradle.
                 configuration.pluginsClasspath.map { File(it.path).toURI().toURL() }
                     .toTypedArray()
@@ -56,7 +59,8 @@ interface DokkaContextConfiguration {
 private class DokkaContextConfigurationImpl(
     override val logger: DokkaLogger,
     override val configuration: DokkaConfiguration,
-    override val platforms: Map<PlatformData, EnvironmentAndFacade>
+    override val platforms: Map<SourceSetData, EnvironmentAndFacade>,
+    override val sourceSetCache: SourceSetCache
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
     private val pluginStubs = mutableMapOf<KClass<*>, DokkaPlugin>()
diff --git a/core/src/main/kotlin/transformers/documentation/PreMergeDocumentableTransformer.kt b/core/src/main/kotlin/transformers/documentation/PreMergeDocumentableTransformer.kt
index dfb1f26b..b67a1d57 100644
--- a/core/src/main/kotlin/transformers/documentation/PreMergeDocumentableTransformer.kt
+++ b/core/src/main/kotlin/transformers/documentation/PreMergeDocumentableTransformer.kt
@@ -4,5 +4,5 @@ import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface PreMergeDocumentableTransformer {
-    operator fun invoke(modules: List<DModule>, context: DokkaContext): List<DModule>
+    operator fun invoke(modules: List<DModule>): List<DModule>
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt b/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
index a138b3e2..f9c0a3d0 100644
--- a/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
+++ b/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.dokka.transformers.sources
 
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface SourceToDocumentableTranslator {
-    fun invoke(platformData: PlatformData, context: DokkaContext): DModule
+    fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index 2da3fbd4..ab7d089d 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -54,15 +54,15 @@ class DokkaBase : DokkaPlugin() {
     }
 
     val preMergeDocumentableTransformer by extending(isFallback = true) {
-        CoreExtensions.preMergeDocumentableTransformer with DocumentableVisibilityFilter
+        CoreExtensions.preMergeDocumentableTransformer providing ::DocumentableVisibilityFilter
     }
 
     val actualTypealiasAdder by extending {
-        CoreExtensions.preMergeDocumentableTransformer with ActualTypealiasAdder()
+        CoreExtensions.preMergeDocumentableTransformer providing ::ActualTypealiasAdder
     }
 
     val modulesAndPackagesDocumentation by extending(isFallback = true) {
-        CoreExtensions.preMergeDocumentableTransformer with ModuleAndPackageDocumentationTransformer
+        CoreExtensions.preMergeDocumentableTransformer providing ::ModuleAndPackageDocumentationTransformer
     }
 
     val kotlinSignatureProvider by extending(isFallback = true) {
diff --git a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
index 925767ce..1340529c 100644
--- a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -3,6 +3,7 @@ package org.jetbrains.dokka.base.renderers
 import kotlinx.coroutines.*
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.local.LocationProvider
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
@@ -26,7 +27,7 @@ abstract class DefaultRenderer<T>(
     abstract fun T.buildList(
         node: ContentList,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        platformRestriction: SourceSetData? = null
     )
 
     abstract fun T.buildNewLine()
@@ -34,7 +35,7 @@ abstract class DefaultRenderer<T>(
     abstract fun T.buildTable(
         node: ContentTable,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        platformRestriction: SourceSetData? = null
     )
 
     abstract fun T.buildText(textNode: ContentText)
@@ -49,7 +50,7 @@ abstract class DefaultRenderer<T>(
     open fun T.buildGroup(
         node: ContentGroup,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        platformRestriction: SourceSetData? = null
     ) =
         wrapGroup(node, pageContext) { node.children.forEach { it.build(this, pageContext, platformRestriction) } }
 
@@ -59,7 +60,7 @@ abstract class DefaultRenderer<T>(
     open fun T.buildLinkText(
         nodes: List<ContentNode>,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        platformRestriction: SourceSetData? = null
     ) {
         nodes.forEach { it.build(this, pageContext, platformRestriction) }
     }
@@ -71,7 +72,7 @@ abstract class DefaultRenderer<T>(
     open fun T.buildHeader(
         node: ContentHeader,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        platformRestriction: SourceSetData? = null
     ) {
         buildHeader(node.level) { node.children.forEach { it.build(this, pageContext, platformRestriction) } }
     }
@@ -79,22 +80,22 @@ abstract class DefaultRenderer<T>(
     open fun ContentNode.build(
         builder: T,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        platformRestriction: SourceSetData? = null
     ) =
         builder.buildContentNode(this, pageContext, platformRestriction)
 
     open fun T.buildContentNode(
         node: ContentNode,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        platformRestriction: SourceSetData? = null
     ) {
-        if (platformRestriction == null || platformRestriction in node.platforms) {
+        if (platformRestriction == null || platformRestriction in node.sourceSets) {
             when (node) {
                 is ContentText -> buildText(node)
                 is ContentHeader -> buildHeader(node, pageContext, platformRestriction)
                 is ContentCode -> buildCode(node.children, node.language, pageContext)
                 is ContentDRILink ->
-                    buildLink(locationProvider.resolve(node.address, node.platforms.toList(), pageContext)) {
+                    buildLink(locationProvider.resolve(node.address, node.sourceSets.toList(), pageContext)) {
                         buildLinkText(node.children, pageContext, platformRestriction)
                     }
                 is ContentResolvedLink -> buildLink(node.address) {
@@ -154,4 +155,4 @@ abstract class DefaultRenderer<T>(
     }
 }
 
-fun ContentPage.platforms() = this.content.platforms.toList()
\ No newline at end of file
+fun ContentPage.platforms() = this.content.sourceSets.toList()
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index c061cabf..caabcda7 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -7,6 +7,7 @@ import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.DefaultRenderer
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.DFunction
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
@@ -42,10 +43,10 @@ open class HtmlRenderer(
     override fun FlowContent.buildPlatformDependent(content: PlatformHintedContent, pageContext: ContentPage) {
         div("platform-hinted") {
             attributes["data-platform-hinted"] = "data-platform-hinted"
-            val contents = content.platforms.mapIndexed { index, platform ->
+            val contents = content.sourceSets.mapIndexed { index, platform ->
                 platform to createHTML(prettyPrint = false).div(classes = "content") {
                     if (index == 0) attributes["data-active"] = ""
-                    attributes["data-togglable"] = platform.targets.joinToString("-")
+                    attributes["data-togglable"] = platform.sourceSetName
                     buildContentNode(content.inner, pageContext, platform)
                 }
             }
@@ -56,8 +57,8 @@ open class HtmlRenderer(
                     contents.forEachIndexed { index, pair ->
                         button(classes = "platform-bookmark") {
                             if (index == 0) attributes["data-active"] = ""
-                            attributes["data-toggle"] = pair.first.targets.joinToString("-")
-                            text(pair.first.targets.joinToString(", "));
+                            attributes["data-toggle"] = pair.first.sourceSetName
+                            text(pair.first.sourceSetName)
                         }
                     }
                 }
@@ -71,27 +72,27 @@ open class HtmlRenderer(
     override fun FlowContent.buildList(
         node: ContentList,
         pageContext: ContentPage,
-        platformRestriction: PlatformData?
-    ) = if (node.ordered) ol { buildListItems(node.children, pageContext, platformRestriction) }
-    else ul { buildListItems(node.children, pageContext, platformRestriction) }
+        sourceSetRestriction: SourceSetData?
+    ) = if (node.ordered) ol { buildListItems(node.children, pageContext, sourceSetRestriction) }
+    else ul { buildListItems(node.children, pageContext, sourceSetRestriction) }
 
     open fun OL.buildListItems(
         items: List<ContentNode>,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        sourceSetRestriction: SourceSetData? = null
     ) {
         items.forEach {
             if (it is ContentList)
                 buildList(it, pageContext)
             else
-                li { it.build(this, pageContext, platformRestriction) }
+                li { it.build(this, pageContext, sourceSetRestriction) }
         }
     }
 
     open fun UL.buildListItems(
         items: List<ContentNode>,
         pageContext: ContentPage,
-        platformRestriction: PlatformData? = null
+        sourceSetRestriction: SourceSetData? = null
     ) {
         items.forEach {
             if (it is ContentList)
@@ -118,64 +119,63 @@ open class HtmlRenderer(
     private fun FlowContent.buildRow(
         node: ContentGroup,
         pageContext: ContentPage,
-        platformRestriction: PlatformData?
+        sourceSetRestriction: SourceSetData?
     ) {
         node.children
             .filter {
-                platformRestriction == null || platformRestriction in it.platforms
+                sourceSetRestriction == null || sourceSetRestriction in it.sourceSets
             }
             .takeIf { it.isNotEmpty() }
             ?.let {
                 div(classes = "table-row") {
                     it.filter { it.dci.kind != ContentKind.Symbol }.takeIf { it.isNotEmpty() }?.let {
                         div("main-subrow ${node.style.joinToString { it.toString().decapitalize() }}") {
-                            it.filter { platformRestriction == null || platformRestriction in it.platforms }
+                            it.filter { sourceSetRestriction == null || sourceSetRestriction in it.sourceSets }
                                 .forEach {
                                     when(it.dci.kind){
-                                        ContentKind.PlatformDependantHint -> {
+                                        ContentKind.SourceSetDependantHint -> {
                                             div("platform-dependant-row keyValue"){
                                                 div()
                                                 div("title"){
-                                                    it.build(this, pageContext, platformRestriction)
+                                                    it.build(this, pageContext, sourceSetRestriction)
                                                 }
                                             }
                                         }
                                         ContentKind.Main -> {
                                             div("title-row"){
-                                                it.build(this, pageContext, platformRestriction)
+                                                it.build(this, pageContext, sourceSetRestriction)
                                                 div()
-                                                if (ContentKind.shouldBePlatformTagged(node.dci.kind) && node.platforms.size == 1) {
+                                                if (ContentKind.shouldBePlatformTagged(node.dci.kind) && node.sourceSets.size == 1) {
                                                     createPlatformTags(node)
                                                 } else {
                                                     div()
                                                 }
                                             }
                                         }
-                                        else -> div { it.build(this, pageContext, platformRestriction) }
+                                        else -> div { it.build(this, pageContext, sourceSetRestriction) }
                                     }
                                 }
                         }
                     }
                     it.filter { it.dci.kind == ContentKind.Symbol }.takeIf { it.isNotEmpty() }?.let {
                         div("signature-subrow") {
-                            div("signatures"){
+                            div("signatures") {
                                 it.forEach {
-                                    it.build(this, pageContext, platformRestriction)
+                                    it.build(this, pageContext, sourceSetRestriction)
                                 }
                             }
                         }
                     }
                 }
-        }
+            }
     }
 
-    private fun FlowContent.createPlatformTags( node: ContentNode ) {
+    private fun FlowContent.createPlatformTags(node: ContentNode) {
         div("platform-tags") {
-            node.platforms.forEach {
+            node.sourceSets.forEach {
                 div("platform-tag") {
-                    val targets = it.targets.joinToString(", ")
-                    if( targets.equals("common", ignoreCase = true) ) classes = classes + "common"
-                    text(it.targets.joinToString(", "))
+                    if (it.sourceSetName.equals("common", ignoreCase = true)) classes = classes + "common"
+                    text(it.sourceSetName)
                 }
             }
         }
@@ -184,11 +184,11 @@ open class HtmlRenderer(
     override fun FlowContent.buildTable(
         node: ContentTable,
         pageContext: ContentPage,
-        platformRestriction: PlatformData?
+        sourceSetRestriction: SourceSetData?
     ) {
         div(classes = "table") {
             node.children.forEach {
-                buildRow(it, pageContext, platformRestriction)
+                buildRow(it, pageContext, sourceSetRestriction)
             }
         }
     }
@@ -221,7 +221,7 @@ open class HtmlRenderer(
 
     fun FlowContent.buildLink(
         to: DRI,
-        platforms: List<PlatformData>,
+        platforms: List<SourceSetData>,
         from: PageNode? = null,
         block: FlowContent.() -> Unit
     ) = buildLink(locationProvider.resolve(to, platforms, from), block)
diff --git a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
index 4b90cc8a..4048c11e 100644
--- a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
@@ -3,8 +3,8 @@ package org.jetbrains.dokka.base.renderers.html
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.pages.RendererSpecificPage
 import org.jetbrains.dokka.pages.RenderingStrategy
 
@@ -41,7 +41,7 @@ class NavigationPage(val root: NavigationNode) : RendererSpecificPage {
 class NavigationNode(
     val name: String,
     val dri: DRI,
-    val platforms: List<PlatformData>,
+    val platforms: List<SourceSetData>,
     val children: List<NavigationNode>
 )
 
diff --git a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
index 29c4a425..322f4927 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
@@ -4,6 +4,8 @@ import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.external.ExternalLocationProvider
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
@@ -46,15 +48,14 @@ open class DefaultLocationProvider(
     override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String =
         pathTo(node, context) + if (!skipExtension) extension else ""
 
-    override fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode?): String =
+    override fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode?): String =
         pagesIndex[dri]?.let { resolve(it, context) } ?:
         // Not found in PageGraph, that means it's an external link
         getLocation(dri,
             this.dokkaContext.configuration.passesConfigurations
                 .filter { passConfig ->
-                    platforms.toSet()
-                        .contains(PlatformData(passConfig.moduleName, passConfig.analysisPlatform, passConfig.targets))
-                } // TODO: change targets to something better?
+                    sourceSets.toSet().contains(dokkaContext.sourceSet(passConfig))
+                }
                 .groupBy({ it.jdkVersion }, { it.externalDocumentationLinks })
                 .map { it.key to it.value.flatten().distinct() }.toMap()
         )
diff --git a/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
index 0814cb3e..c6c48d63 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
@@ -1,12 +1,12 @@
 package org.jetbrains.dokka.base.resolvers.local
 
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.pages.RootPageNode
 
 interface LocationProvider {
-    fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode? = null): String
+    fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode? = null): String
     fun resolve(node: PageNode, context: PageNode? = null, skipExtension: Boolean = false): String
     fun resolveRoot(node: PageNode): String
     fun ancestors(node: PageNode): List<PageNode>
diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
index 313973bf..241103bf 100644
--- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
+++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
@@ -10,7 +10,6 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.WithExtraProperties
 import org.jetbrains.dokka.pages.ContentKind
 import org.jetbrains.dokka.pages.ContentNode
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.pages.TextStyle
 import org.jetbrains.dokka.utilities.DokkaLogger
 
@@ -35,7 +34,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         link(e.name, e.dri)
     }
 
-    private fun actualTypealiasedSignature(dri: DRI, name: String, aliasedTypes: PlatformDependent<Bound>) =
+    private fun actualTypealiasedSignature(dri: DRI, name: String, aliasedTypes: SourceSetDependent<Bound>) =
         aliasedTypes.entries.groupBy({ it.value }, { it.key }).map { (bound, platforms) ->
             contentBuilder.contentFor(dri, platforms.toSet(), ContentKind.Symbol, setOf(TextStyle.Monospace)) {
                 text("actual typealias ")
@@ -49,17 +48,17 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         (c as? WithExtraProperties<out DClasslike>)?.let {
             c.extra[ActualTypealias]?.let {
                 contentBuilder.contentFor(c) {
-                    +regularSignature(c, platformData = c.platformData.toSet() - it.underlyingType.keys)
+                    +regularSignature(c, sourceSets = c.sourceSets.toSet() - it.underlyingType.keys)
                     +actualTypealiasedSignature(c.dri, c.name.orEmpty(), it.underlyingType)
                 }
             } ?: regularSignature(c)
         } ?: regularSignature(c)
 
-    private fun regularSignature(c: DClasslike, platformData: Set<PlatformData> = c.platformData.toSet()) =
-        contentBuilder.contentFor(c, ContentKind.Symbol, setOf(TextStyle.Monospace), platformData = platformData) {
-            platformText(c.visibility, platformData) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " }
+    private fun regularSignature(c: DClasslike, sourceSets: Set<SourceSetData> = c.sourceSets.toSet()) =
+        contentBuilder.contentFor(c, ContentKind.Symbol, setOf(TextStyle.Monospace), sourceSets = sourceSets) {
+            platformText(c.visibility, sourceSets) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " }
             if (c is DClass) {
-                platformText(c.modifier, platformData) {
+                platformText(c.modifier, sourceSets) {
                     if (c.extra[AdditionalModifiers]?.content?.contains(ExtraModifiers.DATA) == true && it.name == "final") "data "
                     else it.name + " "
                 }
@@ -74,23 +73,23 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             link(c.name!!, c.dri)
             if (c is DClass) {
                 val pConstructor = c.constructors.singleOrNull { it.extra[PrimaryConstructorExtra] != null }
-                list(pConstructor?.parameters.orEmpty(), "(", ")", ",", pConstructor?.platformData.orEmpty().toSet()) {
+                list(pConstructor?.parameters.orEmpty(), "(", ")", ",", pConstructor?.sourceSets.orEmpty().toSet()) {
                     text(it.name ?: "", styles = mainStyles.plus(TextStyle.Bold).plus(TextStyle.Indented))
                     text(": ")
                     signatureForProjection(it.type)
                 }
             }
             if (c is WithSupertypes) {
-                c.supertypes.filter { it.key in platformData }.map { (p, dris) ->
-                    list(dris, prefix = " : ", platformData = setOf(p)) {
-                        link(it.sureClassNames, it, platformData = setOf(p))
+                c.supertypes.filter { it.key in sourceSets }.map { (p, dris) ->
+                    list(dris, prefix = " : ", sourceSets = setOf(p)) {
+                        link(it.sureClassNames, it, sourceSets = setOf(p))
                     }
                 }
             }
         }
 
-    private fun propertySignature(p: DProperty, platformData: Set<PlatformData> = p.platformData.toSet()) =
-        contentBuilder.contentFor(p, ContentKind.Symbol, setOf(TextStyle.Monospace), platformData = platformData) {
+    private fun propertySignature(p: DProperty, sourceSets: Set<SourceSetData> = p.sourceSets.toSet()) =
+        contentBuilder.contentFor(p, ContentKind.Symbol, setOf(TextStyle.Monospace), sourceSets = sourceSets) {
             platformText(p.visibility) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " }
             platformText(p.modifier){ it.name + " "}
             p.setter?.let { text("var ") } ?: text("val ")
@@ -106,8 +105,8 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             signatureForProjection(p.type)
         }
 
-    private fun functionSignature(f: DFunction, platformData: Set<PlatformData> = f.platformData.toSet()) =
-        contentBuilder.contentFor(f, ContentKind.Symbol, setOf(TextStyle.Monospace), platformData = platformData) {
+    private fun functionSignature(f: DFunction, sourceSets: Set<SourceSetData> = f.sourceSets.toSet()) =
+        contentBuilder.contentFor(f, ContentKind.Symbol, setOf(TextStyle.Monospace), sourceSets = sourceSets) {
             platformText(f.visibility) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " }
             platformText(f.modifier) { it.name + " " }
             text("fun ")
@@ -147,7 +146,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                     t,
                     ContentKind.Symbol,
                     setOf(TextStyle.Monospace),
-                    platformData = platforms.toSet()
+                    sourceSets = platforms.toSet()
                 ) {
                     platformText(t.visibility) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " }
                     text("typealias ")
@@ -196,8 +195,8 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             is PrimitiveJavaType -> signatureForProjection(p.translateToKotlin())
         }
 
-    private fun funType(dri: DRI, platformData: Set<PlatformData>, type: TypeConstructor) =
-        contentBuilder.contentFor(dri, platformData, ContentKind.Symbol, setOf(TextStyle.Monospace)) {
+    private fun funType(dri: DRI, sourceSets: Set<SourceSetData>, type: TypeConstructor) =
+        contentBuilder.contentFor(dri, sourceSets, ContentKind.Symbol, setOf(TextStyle.Monospace)) {
             if (type.extension) {
                 signatureForProjection(type.projections.first())
                 text(".")
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
index 35f27a94..cab4a9d2 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
@@ -6,8 +6,8 @@ import org.jetbrains.dokka.model.properties.WithExtraProperties
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 
-class ActualTypealiasAdder : PreMergeDocumentableTransformer {
-    override fun invoke(modules: List<DModule>, context: DokkaContext) = modules.map { it.mergeTypealiases() }
+class ActualTypealiasAdder(val context: DokkaContext) : PreMergeDocumentableTransformer {
+    override fun invoke(modules: List<DModule>) = modules.map { it.mergeTypealiases() }
 
     private fun DModule.mergeTypealiases(): DModule = copy(packages = packages.map { pkg ->
         if (pkg.typealiases.isEmpty()) {
@@ -64,11 +64,11 @@ class ActualTypealiasAdder : PreMergeDocumentableTransformer {
         typealiases: Map<DRI, DTypeAlias>
     ): List<T> where T : DClasslike, T : WithExtraProperties<T>, T : WithExpectActual =
         elements.map { element ->
-            if (element.sources.expect != null) {
+            if (element.expectPresentInSet != null) {
                 typealiases[element.dri]?.let { ta ->
                     element.withNewExtras(
                         element.extra + ActualTypealias(
-                            PlatformDependent.from(ta.platformData.single(), ta.underlyingType.values.single())
+                            mapOf(ta.sourceSets.single() to ta.underlyingType.values.single())
                         )
                     )
                 } ?: element
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
index f871cdec..862f9240 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
@@ -2,7 +2,6 @@ package org.jetbrains.dokka.base.transformers.documentables
 
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.mergeExtras
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.DocumentableMerger
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
@@ -24,8 +23,9 @@ internal object DefaultDocumentableMerger : DocumentableMerger {
                     list.flatMap { it.packages },
                     DPackage::mergeWith
                 ),
-                documentation = list.platformDependentFor { documentation },
-                platformData = list.flatMap { it.platformData }.distinct()
+                documentation = list.map { it.documentation }.flatMap { it.entries }.associate { (k,v) -> k to v },
+                expectPresentInSet = list.firstNotNullResult { it.expectPresentInSet },
+                sourceSets = list.flatMap { it.sourceSets }
             ).mergeExtras(left, right)
         }
     }
@@ -36,115 +36,51 @@ private fun <T : Documentable> merge(elements: List<T>, reducer: (T, T) -> T): L
         .reduce { _, left, right -> reducer(left, right) }
         .values.toList()
 
-private fun <T : Any, D : Documentable> Iterable<D>.platformDependentFor(
-    selector: D.() -> PlatformDependent<T>
-): PlatformDependent<T> {
-    val actuals = map { it.selector().map }
-        .flatMap { it.entries }
-        .associate { (k, v) -> k to v }
-
-    val expected = firstNotNullResult { it.selector().expect }
-
-    return PlatformDependent(actuals, expected)
-}
-
-private fun <T : Any> PlatformDependent<T>.mergeWith(other: PlatformDependent<T>) = PlatformDependent(
-    map = this + other,
-    expect = expect ?: other.expect
-)
-
 private fun <T> mergeExpectActual(
     elements: List<T>,
-    reducer: (T, T) -> T,
-    platformSetter: T.(List<PlatformData>) -> T
+    reducer: (T, T) -> T
 ): List<T> where T : Documentable, T : WithExpectActual {
 
-    fun findExpect(actual: T, expects: List<T>): Expect<T> =
-        expects.find { it.platformData.flatMap { it.targets }.containsAll(actual.platformData.flatMap { it.targets }) }
-            .let { Expect.from(it) }
-
-    fun reduceExpectActual(entry: Map.Entry<Expect<T>, List<T>>): List<T> = when (val expect = entry.key) {
-        Expect.NotFound -> entry.value
-        is Expect.Found -> entry.value.plus(expect.expect).reduce(reducer).let(::listOf)
-    }
-
-    fun analyzeExpectActual(sameDriElements: List<T>): List<T> {
-        val pathGrouped: Collection<T> = mutableMapOf<Set<String>, T>().apply {
-            sameDriElements.forEach { documentable ->
-                val paths = documentable.sources.allValues.map { it.path }.toSet()
-                val key = keys.find { it.containsAll(paths) }
-                if (key == null) {
-                    put(paths, documentable)
-                } else {
-                    computeIfPresent(key) { _, old -> reducer(old, documentable) }
-                }
-            }
-        }.values
-        val (expect, actual) = pathGrouped.partition { it.sources.expect != null }
-        val mergedExpect = expect.groupBy { it.sources.expect?.path }.values.map { e ->
-            e.first().platformSetter(e.flatMap { it.platformData }.distinct())
-        }
-        val groupExpectActual = actual.groupBy { findExpect(it, mergedExpect) }
-        val pathsToExpects: Set<String> =
-            groupExpectActual.keys.filterIsInstance<Expect.Found<T>>()
-                .mapNotNull { it.expect.sources.expect?.path }.toSet()
+    fun analyzeExpectActual(sameDriElements: List<T>) = sameDriElements.reduce(reducer)
 
-        return groupExpectActual.flatMap { reduceExpectActual(it) } + expect.filterNot { it.sources.expect?.path in pathsToExpects }
-    }
-
-    return elements.groupBy { it.dri }.values.flatMap(::analyzeExpectActual)
-}
-
-private sealed class Expect<out T : Any> {
-    object NotFound : Expect<Nothing>()
-    data class Found<T : Any>(val expect: T) : Expect<T>()
-
-    companion object {
-        fun <T : Any> from(t: T?) = t?.let(::Found) ?: NotFound
-    }
+    return elements.groupBy { it.dri }.values.map(::analyzeExpectActual)
 }
 
 fun DPackage.mergeWith(other: DPackage): DPackage = copy(
-    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) },
-    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) },
-    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData),
-    documentation = documentation.mergeWith(other.documentation),
+    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith),
+    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith),
+    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith),
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
     typealiases = merge(typealiases + other.typealiases, DTypeAlias::mergeWith),
-    platformData = (platformData + other.platformData).distinct()
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DFunction.mergeWith(other: DFunction): DFunction = copy(
     parameters = merge(this.parameters + other.parameters, DParameter::mergeWith),
     receiver = receiver?.let { r -> other.receiver?.let { r.mergeWith(it) } ?: r } ?: other.receiver,
-    documentation = documentation.mergeWith(other.documentation),
-    sources = sources.mergeWith(other.sources),
-    visibility = visibility.mergeWith(other.visibility),
-    modifier = modifier.mergeWith(other.modifier),
-    platformData = (platformData + other.platformData).distinct(),
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sources = sources+ other.sources,
+    visibility = visibility + other.visibility,
+    modifier = modifier + other.modifier,
+    sourceSets = sourceSets + other.sourceSets,
     generics = merge(generics + other.generics, DTypeParameter::mergeWith)
 ).mergeExtras(this, other)
 
 fun DProperty.mergeWith(other: DProperty): DProperty = copy(
     receiver = receiver?.let { r -> other.receiver?.let { r.mergeWith(it) } ?: r } ?: other.receiver,
-    documentation = documentation.mergeWith(other.documentation),
-    sources = sources.mergeWith(other.sources),
-    visibility = visibility.mergeWith(other.visibility),
-    modifier = modifier.mergeWith(other.modifier),
-    platformData = (platformData + other.platformData).distinct(),
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sources = sources+ other.sources,
+    visibility = visibility + other.visibility,
+    modifier = modifier + other.modifier,
+    sourceSets = sourceSets + other.sourceSets,
     getter = getter?.let { g -> other.getter?.let { g.mergeWith(it) } ?: g } ?: other.getter,
     setter = setter?.let { s -> other.setter?.let { s.mergeWith(it) } ?: s } ?: other.setter,
     generics = merge(generics + other.generics, DTypeParameter::mergeWith)
 ).mergeExtras(this, other)
 
-fun DClasslike.setPlatformData(platformData: List<PlatformData>): DClasslike = when (this) {
-    is DClass -> copy(platformData = platformData)
-    is DEnum -> copy(platformData = platformData)
-    is DInterface -> copy(platformData = platformData)
-    is DObject -> copy(platformData = platformData)
-    is DAnnotation -> copy(platformData = platformData)
-    else -> throw IllegalStateException("${this::class.qualifiedName} ${this.name} cannot have platform set")
-}
-
 fun DClasslike.mergeWith(other: DClasslike): DClasslike = when {
     this is DClass && other is DClass -> mergeWith(other)
     this is DEnum && other is DEnum -> mergeWith(other)
@@ -158,18 +94,19 @@ fun DClass.mergeWith(other: DClass): DClass = copy(
     constructors = mergeExpectActual(
         constructors + other.constructors,
         DFunction::mergeWith
-    ) { copy(platformData = it) },
-    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) },
-    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) },
-    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData),
+    ),
+    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith),
+    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith),
+    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith),
     companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion,
     generics = merge(generics + other.generics, DTypeParameter::mergeWith),
-    modifier = modifier.mergeWith(other.modifier),
-    supertypes = supertypes.mergeWith(other.supertypes),
-    documentation = documentation.mergeWith(other.documentation),
-    sources = sources.mergeWith(other.sources),
-    visibility = visibility.mergeWith(other.visibility),
-    platformData = (platformData + other.platformData).distinct()
+    modifier = modifier + other.modifier,
+    supertypes = supertypes + other.supertypes,
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sources = sources+ other.sources,
+    visibility = visibility + other.visibility,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DEnum.mergeWith(other: DEnum): DEnum = copy(
@@ -177,78 +114,86 @@ fun DEnum.mergeWith(other: DEnum): DEnum = copy(
     constructors = mergeExpectActual(
         constructors + other.constructors,
         DFunction::mergeWith
-    ) { copy(platformData = it) },
-    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) },
-    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) },
-    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData),
+    ),
+    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith),
+    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith),
+    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith),
     companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion,
-    supertypes = supertypes.mergeWith(other.supertypes),
-    documentation = documentation.mergeWith(other.documentation),
-    sources = sources.mergeWith(other.sources),
-    visibility = visibility.mergeWith(other.visibility),
-    platformData = (platformData + other.platformData).distinct()
+    supertypes = supertypes + other.supertypes,
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sources = sources+ other.sources,
+    visibility = visibility + other.visibility,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DEnumEntry.mergeWith(other: DEnumEntry): DEnumEntry = copy(
-    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) },
-    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) },
-    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData),
-    documentation = documentation.mergeWith(other.documentation),
-    platformData = (platformData + other.platformData).distinct()
+    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith),
+    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith),
+    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith),
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DObject.mergeWith(other: DObject): DObject = copy(
-    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) },
-    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) },
-    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData),
-    supertypes = supertypes.mergeWith(other.supertypes),
-    documentation = documentation.mergeWith(other.documentation),
-    sources = sources.mergeWith(other.sources),
-    visibility = visibility.mergeWith(other.visibility),
-    platformData = (platformData + other.platformData).distinct()
+    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith),
+    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith),
+    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith),
+    supertypes = supertypes + other.supertypes,
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sources = sources+ other.sources,
+    visibility = visibility + other.visibility,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DInterface.mergeWith(other: DInterface): DInterface = copy(
-    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) },
-    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) },
-    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData),
+    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith),
+    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith),
+    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith),
     companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion,
     generics = merge(generics + other.generics, DTypeParameter::mergeWith),
-    supertypes = supertypes.mergeWith(other.supertypes),
-    documentation = documentation.mergeWith(other.documentation),
-    sources = sources.mergeWith(other.sources),
-    visibility = visibility.mergeWith(other.visibility),
-    platformData = (platformData + other.platformData).distinct()
+    supertypes = supertypes + other.supertypes,
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sources = sources+ other.sources,
+    visibility = visibility + other.visibility,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DAnnotation.mergeWith(other: DAnnotation): DAnnotation = copy(
     constructors = mergeExpectActual(
         constructors + other.constructors,
         DFunction::mergeWith
-    ) { copy(platformData = it) },
-    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith) { copy(platformData = it) },
-    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith) { copy(platformData = it) },
-    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith, DClasslike::setPlatformData),
+    ),
+    functions = mergeExpectActual(functions + other.functions, DFunction::mergeWith),
+    properties = mergeExpectActual(properties + other.properties, DProperty::mergeWith),
+    classlikes = mergeExpectActual(classlikes + other.classlikes, DClasslike::mergeWith),
     companion = companion?.let { c -> other.companion?.let { c.mergeWith(it) } ?: c } ?: other.companion,
-    documentation = documentation.mergeWith(other.documentation),
-    sources = sources.mergeWith(other.sources),
-    visibility = visibility.mergeWith(other.visibility),
-    platformData = (platformData + other.platformData).distinct()
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sources = sources+ other.sources,
+    visibility = visibility + other.visibility,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DParameter.mergeWith(other: DParameter): DParameter = copy(
-    documentation = documentation.mergeWith(other.documentation),
-    platformData = (platformData + other.platformData).distinct()
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DTypeParameter.mergeWith(other: DTypeParameter): DTypeParameter = copy(
-    documentation = documentation.mergeWith(other.documentation),
-    platformData = (platformData + other.platformData).distinct()
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
 
 fun DTypeAlias.mergeWith(other: DTypeAlias): DTypeAlias = copy(
-    documentation = documentation.mergeWith(other.documentation),
-    underlyingType = underlyingType.mergeWith(other.underlyingType),
-    visibility = visibility.mergeWith(other.visibility),
-    platformData = (platformData + other.platformData).distinct()
+    documentation = documentation + other.documentation,
+    expectPresentInSet = expectPresentInSet ?: other.expectPresentInSet,
+    underlyingType = underlyingType + other.underlyingType,
+    visibility = visibility + other.visibility,
+    sourceSets = sourceSets + other.sourceSets
 ).mergeExtras(this, other)
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt
index c261d2dc..6fdce3a8 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilter.kt
@@ -5,15 +5,14 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.DAnnotation
 import org.jetbrains.dokka.model.DEnum
 import org.jetbrains.dokka.model.DFunction
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 
-internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
+internal class DocumentableVisibilityFilter(val context: DokkaContext) : PreMergeDocumentableTransformer {
 
-    override fun invoke(modules: List<DModule>, context: DokkaContext): List<DModule> = modules.map { original ->
+    override fun invoke(modules: List<DModule>): List<DModule> = modules.map { original ->
         val packageOptions =
-            context.configuration.passesConfigurations.first { original.platformData.contains(it.platformData) }
+            context.configuration.passesConfigurations.first { original.sourceSets.contains(context.sourceSet(it)) }
                 .perPackageOptions
 
         DocumentableFilter(packageOptions).processModule(original)
@@ -36,7 +35,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                         original.name,
                         packages = packages,
                         documentation = original.documentation,
-                        platformData = original.platformData,
+                        sourceSets = original.sourceSets,
                         extra = original.extra
                     )
             }
@@ -69,7 +68,8 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                             classlikes,
                             it.typealiases,
                             it.documentation,
-                            it.platformData,
+                            it.expectPresentInSet,
+                            it.sourceSets,
                             it.extra
                         )
                     }
@@ -78,26 +78,25 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
             return Pair(packagesListChanged, filteredPackages)
         }
 
-        private fun <T : WithVisibility> alwaysTrue(a: T, p: PlatformData) = true
-        private fun <T : WithVisibility> alwaysFalse(a: T, p: PlatformData) = false
+        private fun <T : WithVisibility> alwaysTrue(a: T, p: SourceSetData) = true
+        private fun <T : WithVisibility> alwaysFalse(a: T, p: SourceSetData) = false
 
-        private fun WithVisibility.visibilityForPlatform(data: PlatformData): Visibility? =
-            visibility[data] ?: visibility.expect
+        private fun WithVisibility.visibilityForPlatform(data: SourceSetData): Visibility? = visibility[data]
 
         private fun <T> T.filterPlatforms(
-            additionalCondition: (T, PlatformData) -> Boolean = ::alwaysTrue,
-            alternativeCondition: (T, PlatformData) -> Boolean = ::alwaysFalse
+            additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue,
+            alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse
         ) where T : Documentable, T : WithVisibility =
-            platformData.filter { d ->
+            sourceSets.filter { d ->
                 visibilityForPlatform(d)?.isAllowedInPackage(dri.packageName) == true &&
                         additionalCondition(this, d) ||
                         alternativeCondition(this, d)
             }
 
         private fun <T> List<T>.transform(
-            additionalCondition: (T, PlatformData) -> Boolean = ::alwaysTrue,
-            alternativeCondition: (T, PlatformData) -> Boolean = ::alwaysFalse,
-            recreate: (T, List<PlatformData>) -> T
+            additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue,
+            alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse,
+            recreate: (T, List<SourceSetData>) -> T
         ): Pair<Boolean, List<T>> where T : Documentable, T : WithVisibility {
             var changed = false
             val values = mapNotNull { t ->
@@ -119,7 +118,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
 
         private fun filterFunctions(
             functions: List<DFunction>,
-            additionalCondition: (DFunction, PlatformData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DFunction, SourceSetData) -> Boolean = ::alwaysTrue
         ) =
             functions.transform(additionalCondition) { original, filteredPlatforms ->
                 with(original) {
@@ -129,6 +128,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                         isConstructor,
                         parameters,
                         documentation.filtered(filteredPlatforms),
+                        expectPresentInSet.filtered(filteredPlatforms),
                         sources.filtered(filteredPlatforms),
                         visibility.filtered(filteredPlatforms),
                         type,
@@ -141,13 +141,13 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                 }
             }
 
-        private fun hasVisibleAccessorsForPlatform(property: DProperty, data: PlatformData) =
+        private fun hasVisibleAccessorsForPlatform(property: DProperty, data: SourceSetData) =
             property.getter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true ||
                     property.setter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true
 
         private fun filterProperties(
             properties: List<DProperty>,
-            additionalCondition: (DProperty, PlatformData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DProperty, SourceSetData) -> Boolean = ::alwaysTrue
         ): Pair<Boolean, List<DProperty>> =
             properties.transform(additionalCondition, ::hasVisibleAccessorsForPlatform) { original, filteredPlatforms ->
                 with(original) {
@@ -155,6 +155,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                         dri,
                         name,
                         documentation.filtered(filteredPlatforms),
+                        expectPresentInSet.filtered(filteredPlatforms),
                         sources.filtered(filteredPlatforms),
                         visibility.filtered(filteredPlatforms),
                         type,
@@ -169,16 +170,17 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                 }
             }
 
-        private fun filterEnumEntries(entries: List<DEnumEntry>, filteredPlatforms: List<PlatformData>) =
+        private fun filterEnumEntries(entries: List<DEnumEntry>, filteredPlatforms: List<SourceSetData>) =
             entries.mapNotNull { entry ->
-                if (filteredPlatforms.containsAll(entry.platformData)) entry
+                if (filteredPlatforms.containsAll(entry.sourceSets)) entry
                 else {
-                    val intersection = filteredPlatforms.intersect(entry.platformData).toList()
+                    val intersection = filteredPlatforms.intersect(entry.sourceSets).toList()
                     if (intersection.isEmpty()) null
                     else DEnumEntry(
                         entry.dri,
                         entry.name,
                         entry.documentation.filtered(intersection),
+                        entry.expectPresentInSet.filtered(filteredPlatforms),
                         filterFunctions(entry.functions) { _, data -> data in intersection }.second,
                         filterProperties(entry.properties) { _, data -> data in intersection }.second,
                         filterClasslikes(entry.classlikes) { _, data -> data in intersection }.second,
@@ -190,7 +192,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
 
         private fun filterClasslikes(
             classlikeList: List<DClasslike>,
-            additionalCondition: (DClasslike, PlatformData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DClasslike, SourceSetData) -> Boolean = ::alwaysTrue
         ): Pair<Boolean, List<DClasslike>> {
             var classlikesListChanged = false
             val filteredClasslikes: List<DClasslike> = classlikeList.mapNotNull {
@@ -200,7 +202,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                         classlikesListChanged = true
                         null
                     } else {
-                        var modified = platformData.size != filteredPlatforms.size
+                        var modified = sourceSets.size != filteredPlatforms.size
                         val functions =
                             filterFunctions(functions) { _, data -> data in filteredPlatforms }.let { (listModified, list) ->
                                 modified = modified || listModified
@@ -246,6 +248,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                                 generics,
                                 supertypes.filtered(filteredPlatforms),
                                 documentation.filtered(filteredPlatforms),
+                                expectPresentInSet.filtered(filteredPlatforms),
                                 modifier,
                                 filteredPlatforms,
                                 extra
@@ -254,6 +257,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                                 name,
                                 dri,
                                 documentation.filtered(filteredPlatforms),
+                                expectPresentInSet.filtered(filteredPlatforms),
                                 sources.filtered(filteredPlatforms),
                                 functions,
                                 properties,
@@ -269,6 +273,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                                 name,
                                 enumEntries,
                                 documentation.filtered(filteredPlatforms),
+                                expectPresentInSet.filtered(filteredPlatforms),
                                 sources.filtered(filteredPlatforms),
                                 functions,
                                 properties,
@@ -284,6 +289,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                                 dri,
                                 name,
                                 documentation.filtered(filteredPlatforms),
+                                expectPresentInSet.filtered(filteredPlatforms),
                                 sources.filtered(filteredPlatforms),
                                 functions,
                                 properties,
@@ -299,6 +305,7 @@ internal object DocumentableVisibilityFilter : PreMergeDocumentableTransformer {
                                 name,
                                 dri,
                                 documentation.filtered(filteredPlatforms),
+                                expectPresentInSet.filtered(filteredPlatforms),
                                 sources.filtered(filteredPlatforms),
                                 functions,
                                 properties,
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
index 9cc09d89..15ffc08a 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
@@ -4,7 +4,6 @@ import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.ExtraProperty
 import org.jetbrains.dokka.model.properties.MergeStrategy
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer
 
@@ -12,8 +11,8 @@ class InheritorsExtractorTransformer : DocumentableTransformer {
     override fun invoke(original: DModule, context: DokkaContext): DModule =
         original.generateInheritanceMap().let { inheritanceMap -> original.appendInheritors(inheritanceMap) as DModule }
 
-    private fun <T : Documentable> T.appendInheritors(inheritanceMap: Map<PlatformData, Map<DRI, List<DRI>>>): Documentable =
-        InheritorsInfo(PlatformDependent(inheritanceMap.getForDRI(dri))).let { info ->
+    private fun <T : Documentable> T.appendInheritors(inheritanceMap: Map<SourceSetData, Map<DRI, List<DRI>>>): Documentable =
+        InheritorsInfo(inheritanceMap.getForDRI(dri)).let { info ->
             when (this) {
                 is DModule -> copy(packages = packages.map { it.appendInheritors(inheritanceMap) as DPackage })
                 is DPackage -> copy(classlikes = classlikes.map { it.appendInheritors(inheritanceMap) as DClasslike })
@@ -44,12 +43,12 @@ class InheritorsExtractorTransformer : DocumentableTransformer {
             }
         }
 
-    private fun InheritorsInfo.isNotEmpty() = this.value.allValues.fold(0) { acc, list -> acc + list.size } > 0
+    private fun InheritorsInfo.isNotEmpty() = this.value.values.fold(0) { acc, list -> acc + list.size } > 0
 
-    private fun Map<PlatformData, Map<DRI, List<DRI>>>.getForDRI(dri: DRI) =
-        PlatformDependent(map { (v, k) ->
+    private fun Map<SourceSetData, Map<DRI, List<DRI>>>.getForDRI(dri: DRI) =
+        map { (v, k) ->
             v to k[dri]
-        }.map { (k, v) -> k to v.orEmpty() }.toMap())
+        }.map { (k, v) -> k to v.orEmpty() }.toMap()
 
     private fun DModule.generateInheritanceMap() =
         getInheritanceEntriesRec().filterNot { it.second.isEmpty() }.groupBy({ it.first }) { it.second }
@@ -58,26 +57,24 @@ class InheritorsExtractorTransformer : DocumentableTransformer {
                     .groupBy({ it.first }) { it.second }.map { (k2, v2) -> k2 to v2.flatten() }.toMap()
             }.filter { it.second.values.isNotEmpty() }.toMap()
 
-    private fun <T : Documentable> T.getInheritanceEntriesRec(): List<Pair<PlatformData, List<Pair<DRI, DRI>>>> =
+    private fun <T : Documentable> T.getInheritanceEntriesRec(): List<Pair<SourceSetData, List<Pair<DRI, DRI>>>> =
         this.toInheritanceEntries() + children.flatMap { it.getInheritanceEntriesRec() }
 
     private fun <T : Documentable> T.toInheritanceEntries() =
         (this as? WithSupertypes)?.let {
-            it.supertypes.map.map { (k, v) -> k to v.map { it to dri } }
+            it.supertypes.map { (k, v) -> k to v.map { it to dri } }
         }.orEmpty()
 
 }
 
-class InheritorsInfo(val value: PlatformDependent<List<DRI>>) : ExtraProperty<Documentable> {
+class InheritorsInfo(val value: SourceSetDependent<List<DRI>>) : ExtraProperty<Documentable> {
     companion object : ExtraProperty.Key<Documentable, InheritorsInfo> {
         override fun mergeStrategyFor(left: InheritorsInfo, right: InheritorsInfo): MergeStrategy<Documentable> =
             MergeStrategy.Replace(
                 InheritorsInfo(
-                    PlatformDependent(
-                        (left.value.map.entries.toList() + right.value.map.entries.toList())
+                        (left.value.entries.toList() + right.value.entries.toList())
                             .groupBy({ it.key }) { it.value }
                             .map { (k, v) -> k to v.flatten() }.toMap()
-                    )
                 )
             )
     }
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
index b69c43d3..a886494e 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.dokka.base.transformers.documentables
 
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.PlatformDependent
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
-import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.parsers.MarkdownParser
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
@@ -12,14 +12,14 @@ import java.nio.file.Files
 import java.nio.file.Paths
 
 
-internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableTransformer {
+internal class ModuleAndPackageDocumentationTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
 
-    override fun invoke(original: List<DModule>, context: DokkaContext): List<DModule> {
+    override fun invoke(original: List<DModule>): List<DModule> {
 
         val modulesAndPackagesDocumentation =
             context.configuration.passesConfigurations
                 .map {
-                    Pair(it.moduleName, it.platformData) to
+                    Pair(it.moduleName, context.sourceSet(it)) to
                             it.includes.map { Paths.get(it) }
                                 .also {
                                     it.forEach {
@@ -50,10 +50,10 @@ internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableT
         return original.map { module ->
 
             val moduleDocumentation =
-                module.platformData.mapNotNull { pd ->
+                module.sourceSets.mapNotNull { pd ->
                     val doc = modulesAndPackagesDocumentation[Pair(module.name, pd)]
                     val facade = context.platforms[pd]?.facade
-                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.name}") }
+                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetName}") }
                     try {
                         doc?.get("Module")?.get(module.name)?.run {
                             pd to MarkdownParser(
@@ -68,15 +68,15 @@ internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableT
                     }
                 }.toMap()
 
-            val packagesDocumentation = module.packages.map { dPackage ->
-                dPackage.name to dPackage.platformData.mapNotNull { platformData ->
-                    val doc = modulesAndPackagesDocumentation[Pair(module.name, platformData)]
-                    val facade = context.platforms[platformData]?.facade
-                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${platformData.name}") }
-                    val descriptor = facade.resolveSession.getPackageFragment(FqName(dPackage.name))
-                        ?: return@mapNotNull null.also { context.logger.warn("Could not find descriptor for ${dPackage.name}") }
-                    doc?.get("Package")?.get(dPackage.name)?.run {
-                        platformData to MarkdownParser(
+            val packagesDocumentation = module.packages.map {
+                it.name to it.sourceSets.mapNotNull { pd ->
+                    val doc = modulesAndPackagesDocumentation[Pair(module.name, pd)]
+                    val facade = context.platforms[pd]?.facade
+                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetName}") }
+                    val descriptor = facade.resolveSession.getPackageFragment(FqName(it.name))
+                        ?: return@mapNotNull null.also { context.logger.warn("Could not find descriptor for $") }
+                    doc?.get("Package")?.get(it.name)?.run {
+                        pd to MarkdownParser(
                             facade,
                             descriptor,
                             context.logger
@@ -86,13 +86,11 @@ internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableT
             }.toMap()
 
             module.copy(
-                documentation = module.documentation.let { mergeDocumentation(it.map, moduleDocumentation) },
+                documentation = mergeDocumentation(module.documentation, moduleDocumentation),
                 packages = module.packages.map {
                     val packageDocumentation = packagesDocumentation[it.name]
                     if (packageDocumentation != null && packageDocumentation.isNotEmpty())
-                        it.copy(documentation = it.documentation.let { value ->
-                            mergeDocumentation(value.map, packageDocumentation)
-                        })
+                        it.copy(documentation = mergeDocumentation(it.documentation, packageDocumentation))
                     else
                         it
                 }
@@ -100,10 +98,10 @@ internal object ModuleAndPackageDocumentationTransformer : PreMergeDocumentableT
         }
     }
 
-    private fun mergeDocumentation(origin: Map<PlatformData, DocumentationNode>, new: Map<PlatformData, DocumentationNode>) = PlatformDependent(
+    private fun mergeDocumentation(origin: Map<SourceSetData, DocumentationNode>, new: Map<SourceSetData, DocumentationNode>) =
         (origin.asSequence() + new.asSequence())
             .distinct()
             .groupBy({ it.key }, { it.value })
             .mapValues { (_, values) -> DocumentationNode(values.flatMap { it.children }) }
-    )
+
 }
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
index 778e0498..cb74441e 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.transformers.pages.comments
 
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -8,7 +9,7 @@ interface CommentsToContentConverter {
     fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        platforms: Set<PlatformData>,
+        platforms: Set<SourceSetData>,
         styles: Set<Style> = emptySet(),
         extras: PropertyContainer<ContentNode> = PropertyContainer.empty()
     ): List<ContentNode>
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
index 4e65bae9..85391549 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.transformers.pages.comments
 
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -8,19 +9,19 @@ object DocTagToContentConverter : CommentsToContentConverter {
     override fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        platforms: Set<PlatformData>,
+        sourceSets: Set<SourceSetData>,
         styles: Set<Style>,
         extra: PropertyContainer<ContentNode>
     ): List<ContentNode> {
 
         fun buildChildren(docTag: DocTag, newStyles: Set<Style> = emptySet(), newExtras: SimpleAttr? = null) =
             docTag.children.flatMap {
-                buildContent(it, dci, platforms, styles + newStyles, newExtras?.let { extra + it } ?: extra)
+                buildContent(it, dci, sourceSets, styles + newStyles, newExtras?.let { extra + it } ?: extra)
             }
 
         fun buildTableRows(rows: List<DocTag>, newStyle: Style): List<ContentGroup> =
             rows.flatMap {
-                buildContent(it, dci, platforms, styles + newStyle, extra) as List<ContentGroup>
+                buildContent(it, dci, sourceSets, styles + newStyle, extra) as List<ContentGroup>
             }
 
         fun buildHeader(level: Int) =
@@ -29,7 +30,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                     buildChildren(docTag),
                     level,
                     dci,
-                    platforms,
+                    sourceSets,
                     styles
                 )
             )
@@ -40,7 +41,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                     buildChildren(docTag),
                     ordered,
                     dci,
-                    platforms,
+                    sourceSets,
                     styles,
                     ((PropertyContainer.empty<ContentNode>()) + SimpleAttr("start", start.toString()))
                 )
@@ -48,7 +49,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
 
         fun buildNewLine() = listOf(
             ContentBreakLine(
-                platforms
+                sourceSets
             )
         )
 
@@ -71,7 +72,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                     buildChildren(docTag),
                     docTag.params.get("href")!!,
                     dci,
-                    platforms,
+                    sourceSets,
                     styles
                 )
             )
@@ -83,7 +84,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                         setOf(docTag.dri),
                         ContentKind.Symbol
                     ),
-                    platforms,
+                    sourceSets,
                     styles
                 )
             )
@@ -92,7 +93,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                     buildChildren(docTag),
                     "",
                     dci,
-                    platforms,
+                    sourceSets,
                     styles
                 )
             )
@@ -101,7 +102,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                     buildChildren(docTag),
                     "",
                     dci,
-                    platforms,
+                    sourceSets,
                     styles
                 )
             )
@@ -110,7 +111,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                     address = docTag.params["href"]!!,
                     altText = docTag.params["alt"],
                     dci = dci,
-                    platforms = platforms,
+                    sourceSets = sourceSets,
                     style = styles,
                     extra = extra
                 )
@@ -119,7 +120,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                 ContentText(
                     "",
                     dci,
-                    platforms,
+                    sourceSets,
                     setOf()
                 )
             )
@@ -127,7 +128,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                 ContentText(
                     docTag.body,
                     dci,
-                    platforms,
+                    sourceSets,
                     styles
                 )
             )
@@ -137,7 +138,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
                     buildTableRows(docTag.children.filterIsInstance<Th>(), CommentTable),
                     buildTableRows(docTag.children.filterIsInstance<Tr>(), CommentTable),
                     dci,
-                    platforms,
+                    sourceSets,
                     styles + CommentTable
                 )
             )
@@ -145,10 +146,10 @@ object DocTagToContentConverter : CommentsToContentConverter {
             is Tr -> listOf(
                 ContentGroup(
                     docTag.children.map {
-                        ContentGroup(buildChildren(it), dci, platforms, styles, extra)
+                        ContentGroup(buildChildren(it), dci, sourceSets, styles, extra)
                     },
                     dci,
-                    platforms,
+                    sourceSets,
                     styles
                 )
             )
diff --git a/plugins/base/src/main/kotlin/transformers/pages/merger/SameMethodNamePageMergerStrategy.kt b/plugins/base/src/main/kotlin/transformers/pages/merger/SameMethodNamePageMergerStrategy.kt
index fb904f47..31e79555 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/merger/SameMethodNamePageMergerStrategy.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/merger/SameMethodNamePageMergerStrategy.kt
@@ -32,6 +32,6 @@ object SameMethodNamePageMergerStrategy : PageMergerStrategy {
     }
 
     fun asGroup(dci: DCI, nodes: List<ContentNode>): ContentGroup =
-        nodes.first().let { ContentGroup(nodes, dci, it.platforms, it.style, it.extra) }
+        nodes.first().let { ContentGroup(nodes, dci, it.sourceSets, it.style, it.extra) }
 
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
index 78fc4d33..9b04af40 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
@@ -8,8 +8,10 @@ import org.jetbrains.dokka.analysis.AnalysisEnvironment
 import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.base.renderers.platforms
 import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.Sample
 import org.jetbrains.dokka.model.properties.PropertyContainer
+import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.pages.PageTransformer
@@ -31,16 +33,16 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         val analysis = setUpAnalysis(context)
 
         return input.transformContentPagesTree { page ->
-            page.documentable?.documentation?.allEntries?.fold(page) { acc, entry ->
-                entry.second.children.filterIsInstance<Sample>().fold(acc) { acc, sample ->
-                    acc.modified(content = acc.content.addSample(page, entry.first, sample.name, analysis))
+            page.documentable?.documentation?.entries?.fold(page) { acc, entry ->
+                entry.value.children.filterIsInstance<Sample>().fold(acc) { acc, sample ->
+                    acc.modified(content = acc.content.addSample(page, entry.key, sample.name, analysis))
                 }
             } ?: page
         }
     }
 
     private fun setUpAnalysis(context: DokkaContext) = context.configuration.passesConfigurations.map {
-        it.platformData to AnalysisEnvironment(DokkaGenerator.DokkaMessageCollector(context.logger), it.analysisPlatform).run {
+        context.sourceSet(it) to AnalysisEnvironment(DokkaGenerator.DokkaMessageCollector(context.logger), it.analysisPlatform).run {
             if (analysisPlatform == Platform.jvm) {
                 addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
             }
@@ -56,12 +58,9 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         }
     }.toMap()
 
-    private fun ContentNode.addSample(contentPage: ContentPage, platform: PlatformData?, fqName: String, analysis: Map<PlatformData, EnvironmentAndFacade>): ContentNode {
-        val facade = if(platform == null) {
-            analysis.entries.find { it.key.platformType.name == "common" }?.value
-        } else {
-            analysis[platform]
-        }?.facade ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${platform?.name ?: "expect"}") }
+    private fun ContentNode.addSample(contentPage: ContentPage, platform: SourceSetData, fqName: String, analysis: Map<SourceSetData, EnvironmentAndFacade>): ContentNode {
+        val facade = analysis[platform]?.facade ?:
+            return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleName}")}
         val psiElement = fqNameToPsiElement(facade, fqName) ?:
             return this.also { context.logger.warn("Cannot find PsiElement corresponding to $fqName") }
         val imports = processImports(psiElement) // TODO: Process somehow imports. Maybe just attach them at the top of each body
@@ -96,13 +95,13 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         return DescriptorToSourceUtils.descriptorToDeclaration(symbol)
     }
 
-    private fun contentCode(platforms: List<PlatformData>, dri: Set<DRI>, content: String, language: String) =
+    private fun contentCode(sourceSets: List<SourceSetData>, dri: Set<DRI>, content: String, language: String) =
         ContentCode(
             children = listOf(
                 ContentText(
                     text = content,
                     dci = DCI(dri, ContentKind.BriefComment),
-                    platforms = platforms.toSet(),
+                    sourceSets = sourceSets.toSet(),
                     style = emptySet(),
                     extra = PropertyContainer.empty()
                 )
@@ -110,7 +109,7 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
             language = language,
             extra = PropertyContainer.empty(),
             dci = DCI(dri, ContentKind.Source),
-            platforms = platforms.toSet(),
+            sourceSets = sourceSets.toSet(),
             style = emptySet()
         )
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
index fa73e757..876326d1 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
@@ -5,9 +5,12 @@ import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.model.DescriptorDocumentableSource
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.DocumentableSource
 import org.jetbrains.dokka.model.PsiDocumentableSource
 import org.jetbrains.dokka.model.WithExpectActual
+import org.jetbrains.dokka.model.properties.PropertyContainer
+import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.pages.PageTransformer
@@ -30,11 +33,11 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
         }
 
     private fun getSourceLinks() = context.configuration.passesConfigurations
-        .flatMap { it.sourceLinks.map { sl -> SourceLink(sl, it.platformData) } }
+        .flatMap { it.sourceLinks.map { sl -> SourceLink(sl, context.sourceSetCache.getSourceSet(it)) } }
 
     private fun resolveSources(documentable: WithExpectActual) = documentable.sources
         .mapNotNull { entry ->
-            getSourceLinks().find { entry.value.path.contains(it.path) && it.platformData == entry.key }?.let {
+            getSourceLinks().find { entry.value.path.contains(it.path) && it.sourceSetData == entry.key }?.let {
                 Pair(
                     entry.key,
                     entry.value.toLink(it)
@@ -42,7 +45,7 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
             }
         }
 
-    private fun ContentPage.addSourcesContent(sources: List<Pair<PlatformData, String>>) = builder
+    private fun ContentPage.addSourcesContent(sources: List<Pair<SourceSetData, String>>) = builder
         .buildSourcesContent(this, sources)
         .let {
             this.modified(
@@ -52,10 +55,10 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
 
     private fun PageContentBuilder.buildSourcesContent(
         node: ContentPage,
-        sources: List<Pair<PlatformData, String>>
+        sources: List<Pair<SourceSetData, String>>
     ) = contentFor(
         node.dri.first(),
-        node.documentable!!.platformData.toSet()
+        node.documentable!!.sourceSets.toSet()
     ) {
         header(2) { text("Sources") }
         +ContentTable(
@@ -66,7 +69,7 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
                 }
             },
             DCI(node.dri, ContentKind.Source),
-            node.documentable!!.platformData.toSet(),
+            node.documentable!!.sourceSets.toSet(),
             style = emptySet()
         )
     }
@@ -94,7 +97,7 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
             else -> ContentGroup(
                 children = listOf(this, table),
                 extra = this.extra,
-                platforms = this.platforms,
+                sourceSets = this.sourceSets,
                 dci = this.dci,
                 style = this.style
             )
@@ -107,8 +110,8 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
     }
 }
 
-data class SourceLink(val path: String, val url: String, val lineSuffix: String?, val platformData: PlatformData) {
-    constructor(sourceLinkDefinition: DokkaConfiguration.SourceLinkDefinition, platformData: PlatformData) : this(
-        sourceLinkDefinition.path, sourceLinkDefinition.url, sourceLinkDefinition.lineSuffix, platformData
+data class SourceLink(val path: String, val url: String, val lineSuffix: String?, val sourceSetData: SourceSetData) {
+    constructor(sourceLinkDefinition: DokkaConfiguration.SourceLinkDefinition, sourceSetData: SourceSetData) : this(
+        sourceLinkDefinition.path, sourceLinkDefinition.url, sourceLinkDefinition.lineSuffix, sourceSetData
     )
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index 128b9bd4..7cc96a24 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -7,7 +7,6 @@ import org.jetbrains.dokka.links.withClass
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.parsers.MarkdownParser
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.utilities.DokkaLogger
@@ -20,6 +19,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
 import org.jetbrains.kotlin.idea.kdoc.findKDoc
+import org.jetbrains.kotlin.load.kotlin.toSourceElement
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.calls.components.isVararg
@@ -37,35 +37,35 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 object DefaultDescriptorToDocumentableTranslator : SourceToDocumentableTranslator {
 
-    override fun invoke(platformData: PlatformData, context: DokkaContext): DModule {
+    override fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule {
 
-        val (environment, facade) = context.platforms.getValue(platformData)
+        val (environment, facade) = context.platforms.getValue(sourceSet)
         val packageFragments = environment.getSourceFiles().asSequence()
             .map { it.packageFqName }
             .distinct()
             .mapNotNull { facade.resolveSession.getPackageFragment(it) }
             .toList()
 
-        return DokkaDescriptorVisitor(platformData, context.platforms.getValue(platformData).facade, context.logger).run {
+        return DokkaDescriptorVisitor(sourceSet, context.platforms.getValue(sourceSet).facade, context.logger).run {
             packageFragments.mapNotNull { it.safeAs<PackageFragmentDescriptor>() }.map {
                 visitPackageFragmentDescriptor(
                     it,
-                    DRIWithPlatformInfo(DRI.topLevel, PlatformDependent.empty())
+                    DRIWithPlatformInfo(DRI.topLevel, emptyMap())
                 )
             }
-        }.let { DModule(platformData.name, it, PlatformDependent.empty(), listOf(platformData)) }
+        }.let { DModule(sourceSet.moduleName, it, emptyMap(), null, listOf(sourceSet)) }
     }
 }
 
 data class DRIWithPlatformInfo(
     val dri: DRI,
-    val actual: PlatformDependent<DocumentableSource>
+    val actual: SourceSetDependent<DocumentableSource>
 )
 
-fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, PlatformDependent.empty())
+fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, emptyMap())
 
 private class DokkaDescriptorVisitor(
-    private val platformData: PlatformData,
+    private val sourceSet: SourceSetData,
     private val resolutionFacade: DokkaResolutionFacade,
     private val logger: DokkaLogger
 ) : DeclarationDescriptorVisitorEmptyBodies<Documentable, DRIWithPlatformInfo>() {
@@ -73,23 +73,30 @@ private class DokkaDescriptorVisitor(
         throw IllegalStateException("${javaClass.simpleName} should never enter ${descriptor.javaClass.simpleName}")
     }
 
+    private fun Collection<DeclarationDescriptor>.filterDescriptorsInSourceSet() = filter {
+            val path = it.toSourceElement.containingFile.toString()
+            path.isNotBlank() && sourceSet.sourceRoots.any { root -> path.startsWith(root.path) }
+    }
+
+    private fun <T> T.toSourceSetDependent() = mapOf(sourceSet to this)
+
     override fun visitPackageFragmentDescriptor(
         descriptor: PackageFragmentDescriptor,
         parent: DRIWithPlatformInfo
     ): DPackage {
-        val name = descriptor.fqName.asString().takeUnless { it.isBlank() }
-            ?: "[" + platformData.targets.joinToString(" ") + " root]"// TODO: error-prone, find a better way to do it
+        val name = descriptor.fqName.asString().takeUnless { it.isBlank() } ?:
+            "[${sourceSet.sourceSetName} root]"// TODO: error-prone, find a better way to do it
         val driWithPlatform = DRI(packageName = name).withEmptyInfo()
         val scope = descriptor.getMemberScope()
 
         return DPackage(
             dri = driWithPlatform.dri,
-            functions = scope.functions(driWithPlatform),
-            properties = scope.properties(driWithPlatform),
-            classlikes = scope.classlikes(driWithPlatform),
-            typealiases = scope.typealiases(driWithPlatform),
-            documentation = descriptor.resolveDescriptorData(platformData),
-            platformData = listOf(platformData)
+            functions = scope.functions(driWithPlatform, true),
+            properties = scope.properties(driWithPlatform, true),
+            classlikes = scope.classlikes(driWithPlatform, true),
+            typealiases = scope.typealiases(driWithPlatform, true),
+            documentation = descriptor.resolveDescriptorData(),
+            sourceSets = listOf(sourceSet)
         )
     }
 
@@ -106,7 +113,7 @@ private class DokkaDescriptorVisitor(
         val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
         val scope = descriptor.unsubstitutedMemberScope
         val isExpect = descriptor.isExpect
-        val info = descriptor.resolveClassDescriptionData(if (!isExpect) platformData else null)
+        val info = descriptor.resolveClassDescriptionData()
 
 
         return DInterface(
@@ -116,14 +123,13 @@ private class DokkaDescriptorVisitor(
             properties = scope.properties(driWithPlatform),
             classlikes = scope.classlikes(driWithPlatform),
             sources = descriptor.createSources(),
-            visibility = if (isExpect) PlatformDependent.expectFrom(descriptor.visibility.toDokkaVisibility())
-            else PlatformDependent.from(platformData, descriptor.visibility.toDokkaVisibility()),
-            supertypes = if (isExpect) PlatformDependent.expectFrom(info.supertypes)
-            else PlatformDependent.from(platformData, info.supertypes),
+            expectPresentInSet = sourceSet.takeIf { isExpect },
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
+            supertypes = info.supertypes.toSourceSetDependent(),
             documentation = info.docs,
             generics = descriptor.typeConstructor.parameters.map { it.toTypeParameter() },
             companion = descriptor.companion(driWithPlatform),
-            platformData = listOf(platformData),
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations())
         )
     }
@@ -132,7 +138,7 @@ private class DokkaDescriptorVisitor(
         val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
         val scope = descriptor.unsubstitutedMemberScope
         val isExpect = descriptor.isExpect
-        val info = descriptor.resolveClassDescriptionData(if (!isExpect) platformData else null)
+        val info = descriptor.resolveClassDescriptionData()
 
 
         return DObject(
@@ -142,12 +148,11 @@ private class DokkaDescriptorVisitor(
             properties = scope.properties(driWithPlatform),
             classlikes = scope.classlikes(driWithPlatform),
             sources = descriptor.createSources(),
-            visibility = if (isExpect) PlatformDependent.expectFrom(descriptor.visibility.toDokkaVisibility())
-            else PlatformDependent.from(platformData, descriptor.visibility.toDokkaVisibility()),
-            supertypes = if (isExpect) PlatformDependent.expectFrom(info.supertypes)
-            else PlatformDependent.from(platformData, info.supertypes),
+            expectPresentInSet = sourceSet.takeIf { isExpect },
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
+            supertypes = info.supertypes.toSourceSetDependent(),
             documentation = info.docs,
-            platformData = listOf(platformData),
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations())
         )
     }
@@ -156,7 +161,7 @@ private class DokkaDescriptorVisitor(
         val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
         val scope = descriptor.unsubstitutedMemberScope
         val isExpect = descriptor.isExpect
-        val info = descriptor.resolveClassDescriptionData(if (!isExpect) platformData else null)
+        val info = descriptor.resolveClassDescriptionData()
 
         return DEnum(
             dri = driWithPlatform.dri,
@@ -167,13 +172,12 @@ private class DokkaDescriptorVisitor(
             properties = scope.properties(driWithPlatform),
             classlikes = scope.classlikes(driWithPlatform),
             sources = descriptor.createSources(),
-            visibility = if (isExpect) PlatformDependent.expectFrom(descriptor.visibility.toDokkaVisibility())
-            else PlatformDependent.from(platformData, descriptor.visibility.toDokkaVisibility()),
-            supertypes = if (isExpect) PlatformDependent.expectFrom(info.supertypes)
-            else PlatformDependent.from(platformData, info.supertypes),
+            expectPresentInSet = sourceSet.takeIf { isExpect },
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
+            supertypes = info.supertypes.toSourceSetDependent(),
             documentation = info.docs,
             companion = descriptor.companion(driWithPlatform),
-            platformData = listOf(platformData),
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations())
         )
     }
@@ -186,11 +190,12 @@ private class DokkaDescriptorVisitor(
         return DEnumEntry(
             dri = driWithPlatform.dri,
             name = descriptor.name.asString(),
-            documentation = descriptor.resolveDescriptorData(if (!isExpect) platformData else null),
+            documentation = descriptor.resolveDescriptorData(),
             classlikes = scope.classlikes(driWithPlatform),
             functions = scope.functions(driWithPlatform),
             properties = scope.properties(driWithPlatform),
-            platformData = listOf(platformData),
+            sourceSets = listOf(sourceSet),
+            expectPresentInSet = sourceSet.takeIf { isExpect },
             extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations())
         )
     }
@@ -202,14 +207,15 @@ private class DokkaDescriptorVisitor(
         return DAnnotation(
             dri = driWithPlatform.dri,
             name = descriptor.name.asString(),
-            documentation = descriptor.resolveDescriptorData(platformData),
+            documentation = descriptor.resolveDescriptorData(),
             classlikes = scope.classlikes(driWithPlatform),
             functions = scope.functions(driWithPlatform),
             properties = scope.properties(driWithPlatform),
-            platformData = listOf(platformData),
+            expectPresentInSet = null,
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations()),
             companion = descriptor.companionObjectDescriptor?.let { objectDescriptor(it, driWithPlatform) },
-            visibility = PlatformDependent(mapOf(platformData to descriptor.visibility.toDokkaVisibility())),
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
             constructors = descriptor.constructors.map { visitConstructorDescriptor(it, driWithPlatform) },
             sources = descriptor.createSources()
         )
@@ -219,7 +225,7 @@ private class DokkaDescriptorVisitor(
         val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
         val scope = descriptor.unsubstitutedMemberScope
         val isExpect = descriptor.isExpect
-        val info = descriptor.resolveClassDescriptionData(if (!isExpect) platformData else null)
+        val info = descriptor.resolveClassDescriptionData()
         val actual = descriptor.createSources()
 
         return DClass(
@@ -229,23 +235,21 @@ private class DokkaDescriptorVisitor(
                 visitConstructorDescriptor(
                     it,
                     if (it.isPrimary) DRIWithPlatformInfo(driWithPlatform.dri, actual)
-                    else DRIWithPlatformInfo(driWithPlatform.dri, PlatformDependent.empty())
+                    else DRIWithPlatformInfo(driWithPlatform.dri, emptyMap())
                 )
             },
             functions = scope.functions(driWithPlatform),
             properties = scope.properties(driWithPlatform),
             classlikes = scope.classlikes(driWithPlatform),
             sources = actual,
-            visibility = if (isExpect) PlatformDependent.expectFrom(descriptor.visibility.toDokkaVisibility())
-            else PlatformDependent.from(platformData, descriptor.visibility.toDokkaVisibility()),
-            supertypes = if (isExpect) PlatformDependent.expectFrom(info.supertypes)
-            else PlatformDependent.from(platformData, info.supertypes),
+            expectPresentInSet = sourceSet.takeIf { isExpect },
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
+            supertypes = info.supertypes.toSourceSetDependent(),
             generics = descriptor.typeConstructor.parameters.map { it.toTypeParameter() },
             documentation = info.docs,
-            modifier = if (isExpect) PlatformDependent.expectFrom(descriptor.modifier())
-            else PlatformDependent.from(platformData, descriptor.modifier()),
+            modifier =   descriptor.modifier().toSourceSetDependent(),
             companion = descriptor.companion(driWithPlatform),
-            platformData = listOf(platformData),
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations())
         )
     }
@@ -268,13 +272,12 @@ private class DokkaDescriptorVisitor(
             setter = descriptor.accessors.filterIsInstance<PropertySetterDescriptor>().singleOrNull()?.let {
                 visitPropertyAccessorDescriptor(it, descriptor, dri)
             },
-            visibility = if (isExpect) PlatformDependent.expectFrom(descriptor.visibility.toDokkaVisibility())
-            else PlatformDependent.from(platformData, descriptor.visibility.toDokkaVisibility()),
-            documentation = descriptor.resolveDescriptorData(if (!isExpect) platformData else null),
-            modifier = if (isExpect) PlatformDependent.expectFrom(descriptor.modifier())
-            else PlatformDependent.from(platformData, descriptor.modifier()),
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
+            documentation = descriptor.resolveDescriptorData(),
+            modifier = descriptor.modifier().toSourceSetDependent(),
             type = descriptor.returnType!!.toBound(),
-            platformData = listOf(platformData),
+            expectPresentInSet = sourceSet.takeIf { isExpect },
+            sourceSets = listOf(sourceSet),
             generics = descriptor.typeParameters.map { it.toTypeParameter() },
             extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations())
         )
@@ -301,15 +304,14 @@ private class DokkaDescriptorVisitor(
             parameters = descriptor.valueParameters.mapIndexed { index, desc ->
                 parameter(index, desc, DRIWithPlatformInfo(dri, actual))
             },
+            expectPresentInSet = sourceSet.takeIf { isExpect },
             sources = actual,
-            visibility = if (isExpect) PlatformDependent.expectFrom(descriptor.visibility.toDokkaVisibility())
-            else PlatformDependent.from(platformData, descriptor.visibility.toDokkaVisibility()),
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
             generics = descriptor.typeParameters.map { it.toTypeParameter() },
-            documentation = descriptor.resolveDescriptorData(if (!isExpect) platformData else null),
-            modifier = if (isExpect) PlatformDependent.expectFrom(descriptor.modifier())
-            else PlatformDependent.from(platformData, descriptor.modifier()),
+            documentation = descriptor.resolveDescriptorData(),
+            modifier = descriptor.modifier().toSourceSetDependent(),
             type = descriptor.returnType!!.toBound(),
-            platformData = listOf(platformData),
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll(
                 InheritedFunction(isInherited),
                 descriptor.additionalExtras(), descriptor.getAnnotations()
@@ -333,41 +335,27 @@ private class DokkaDescriptorVisitor(
                 parameter(index, desc, DRIWithPlatformInfo(dri, actual))
             },
             sources = actual,
-            visibility = if (isExpect) PlatformDependent.expectFrom(descriptor.visibility.toDokkaVisibility())
-            else PlatformDependent.from(platformData, descriptor.visibility.toDokkaVisibility()),
-            documentation = descriptor.resolveDescriptorData(if (!isExpect) platformData else null).let {
+            expectPresentInSet = sourceSet.takeIf { isExpect },
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
+            documentation = descriptor.resolveDescriptorData().let { sourceSetDependent ->
                 if (descriptor.isPrimary) {
-                    it.copy(
-                        map = PlatformDependent.from(it.map.map {
-                            Pair(
-                                it.key,
-                                it.value.copy(children = (it.value.children.find { it is Constructor }?.root?.let { constructor ->
-                                    listOf(
-                                        Description(constructor)
-                                    )
-                                } ?: emptyList<TagWrapper>()) + it.value.children.filterIsInstance<Param>())
-                            )
-                        }),
-                        expect = it.expect?.copy(children = (it.expect?.children?.find { it is Constructor }?.root?.let { constructor ->
-                            listOf(
-                                Description(constructor)
-                            )
-                        } ?: emptyList<TagWrapper>()) + it.expect!!.children.filterIsInstance<Param>())
-                    )
+                    sourceSetDependent.map { entry ->
+                        Pair(entry.key, entry.value.copy(children = (entry.value.children.find { it is Constructor }?.root?.let { constructor ->
+                            listOf( Description(constructor) )
+                        } ?: emptyList<TagWrapper>()) + entry.value.children.filterIsInstance<Param>()))
+                    }.toMap()
                 } else {
-                    it
+                    sourceSetDependent
                 }
             },
             type = descriptor.returnType.toBound(),
-            modifier = if (isExpect) PlatformDependent.expectFrom(descriptor.modifier())
-            else PlatformDependent.from(platformData, descriptor.modifier()),
+            modifier = descriptor.modifier().toSourceSetDependent(),
             generics = descriptor.typeParameters.map { it.toTypeParameter() },
-            platformData = listOf(platformData),
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll<DFunction>(descriptor.additionalExtras(), descriptor.getAnnotations())
                 .let {
-                    if (descriptor.isPrimary) {
-                        it + PrimaryConstructorExtra
-                    } else it
+                    if(descriptor.isPrimary) { it + PrimaryConstructorExtra }
+                    else it
                 }
         )
     }
@@ -379,8 +367,9 @@ private class DokkaDescriptorVisitor(
         dri = parent.dri.copy(target = 0),
         name = null,
         type = descriptor.type.toBound(),
-        documentation = descriptor.resolveDescriptorData(platformData),
-        platformData = listOf(platformData)
+        expectPresentInSet = null,
+        documentation = descriptor.resolveDescriptorData(),
+        sourceSets = listOf(sourceSet)
     )
 
     private fun visitPropertyAccessorDescriptor(
@@ -397,8 +386,9 @@ private class DokkaDescriptorVisitor(
                 parent.copy(target = 1),
                 this.name.asString(),
                 type = this.type.toBound(),
-                documentation = descriptor.resolveDescriptorData(if (!isExpect) platformData else null),
-                platformData = listOf(platformData),
+                expectPresentInSet = sourceSet.takeIf { isExpect },
+                documentation = descriptor.resolveDescriptorData(),
+                sourceSets = listOf(sourceSet),
                 extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations())
             )
 
@@ -420,13 +410,12 @@ private class DokkaDescriptorVisitor(
             name,
             isConstructor = false,
             parameters = parameters,
-            visibility = if (isExpect) PlatformDependent.expectFrom(descriptor.visibility.toDokkaVisibility())
-            else PlatformDependent.from(platformData, descriptor.visibility.toDokkaVisibility()),
-            documentation = descriptor.resolveDescriptorData(if (!isExpect) platformData else null),
+            visibility = descriptor.visibility.toDokkaVisibility().toSourceSetDependent(),
+            documentation = descriptor.resolveDescriptorData(),
             type = descriptor.returnType!!.toBound(),
             generics = descriptor.typeParameters.map { it.toTypeParameter() },
-            modifier = if (isExpect) PlatformDependent.expectFrom(descriptor.modifier())
-            else PlatformDependent.from(platformData, descriptor.modifier()),
+            modifier = descriptor.modifier().toSourceSetDependent(),
+            expectPresentInSet = sourceSet.takeIf { isExpect },
             receiver = descriptor.extensionReceiverParameter?.let {
                 visitReceiverParameterDescriptor(
                     it,
@@ -434,7 +423,7 @@ private class DokkaDescriptorVisitor(
                 )
             },
             sources = descriptor.createSources(),
-            platformData = listOf(platformData),
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll(descriptor.additionalExtras(), descriptor.getAnnotations())
         )
     }
@@ -445,11 +434,11 @@ private class DokkaDescriptorVisitor(
                 dri = DRI.from(this),
                 name = name.asString(),
                 type = defaultType.toBound(),
-                underlyingType = PlatformDependent.from(platformData, underlyingType.toBound()),
-                visibility = if (isExpect) PlatformDependent.expectFrom(visibility.toDokkaVisibility())
-                else PlatformDependent.from(platformData, visibility.toDokkaVisibility()),
-                documentation = resolveDescriptorData(platformData),
-                platformData = listOf(platformData)
+                expectPresentInSet = null,
+                underlyingType = underlyingType.toBound().toSourceSetDependent(),
+                visibility = visibility.toDokkaVisibility().toSourceSetDependent(),
+                documentation = resolveDescriptorData(),
+                sourceSets = listOf(sourceSet)
             )
         }
 
@@ -458,8 +447,9 @@ private class DokkaDescriptorVisitor(
             dri = parent.dri.copy(target = index + 1),
             name = descriptor.name.asString(),
             type = descriptor.type.toBound(),
-            documentation = descriptor.resolveDescriptorData(platformData),
-            platformData = listOf(platformData),
+            expectPresentInSet = null,
+            documentation = descriptor.resolveDescriptorData(),
+            sourceSets = listOf(sourceSet),
             extra = PropertyContainer.withAll(
                 listOfNotNull(
                     descriptor.additionalExtras(),
@@ -468,18 +458,23 @@ private class DokkaDescriptorVisitor(
             )
         )
 
-    private fun MemberScope.functions(parent: DRIWithPlatformInfo): List<DFunction> =
-        getContributedDescriptors(DescriptorKindFilter.FUNCTIONS) { true }
+    private fun MemberScope.getContributedDescriptors(kindFilter: DescriptorKindFilter, shouldFilter: Boolean) =
+        getContributedDescriptors(kindFilter) { true }.let {
+            if (shouldFilter) it.filterDescriptorsInSourceSet() else it
+        }
+
+    private fun MemberScope.functions(parent: DRIWithPlatformInfo, packageLevel: Boolean = false): List<DFunction> =
+        getContributedDescriptors(DescriptorKindFilter.FUNCTIONS, packageLevel)
             .filterIsInstance<FunctionDescriptor>()
             .map { visitFunctionDescriptor(it, parent) }
 
-    private fun MemberScope.properties(parent: DRIWithPlatformInfo): List<DProperty> =
-        getContributedDescriptors(DescriptorKindFilter.VALUES) { true }
+    private fun MemberScope.properties(parent: DRIWithPlatformInfo, packageLevel: Boolean = false): List<DProperty> =
+        getContributedDescriptors(DescriptorKindFilter.VALUES, packageLevel)
             .filterIsInstance<PropertyDescriptor>()
             .map { visitPropertyDescriptor(it, parent) }
 
-    private fun MemberScope.classlikes(parent: DRIWithPlatformInfo): List<DClasslike> =
-        getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) { true }
+    private fun MemberScope.classlikes(parent: DRIWithPlatformInfo, packageLevel: Boolean = false): List<DClasslike> =
+        getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS, packageLevel)
             .filter { it is ClassDescriptor && it.kind != ClassKind.ENUM_ENTRY }
             .map { visitClassDescriptor(it as ClassDescriptor, parent) }
             .mapNotNull { it as? DClasslike }
@@ -489,8 +484,8 @@ private class DokkaDescriptorVisitor(
             .filterIsInstance<PackageFragmentDescriptor>()
             .map { visitPackageFragmentDescriptor(it, parent) }
 
-    private fun MemberScope.typealiases(parent: DRIWithPlatformInfo): List<DTypeAlias> =
-        getContributedDescriptors(DescriptorKindFilter.TYPE_ALIASES) { true }
+    private fun MemberScope.typealiases(parent: DRIWithPlatformInfo, packageLevel: Boolean = false): List<DTypeAlias> =
+        getContributedDescriptors(DescriptorKindFilter.TYPE_ALIASES, packageLevel)
             .filterIsInstance<TypeAliasDescriptor>()
             .map { visitTypeAliasDescriptor(it, parent) }
 
@@ -500,19 +495,14 @@ private class DokkaDescriptorVisitor(
             .filter { it.kind == ClassKind.ENUM_ENTRY }
             .map { enumEntryDescriptor(it, parent) }
 
-    private fun DeclarationDescriptor.resolveDescriptorData(platformData: PlatformData?): PlatformDependent<DocumentationNode> = getDocumentation().let {
-        if (it.children.isEmpty())
-            PlatformDependent.empty()
-        else if (platformData != null)
-            PlatformDependent.from(platformData, it)
-        else
-            PlatformDependent.expectFrom(it)
-    }
 
-    private fun ClassDescriptor.resolveClassDescriptionData(platformData: PlatformData?): ClassInfo {
+    private fun DeclarationDescriptor.resolveDescriptorData(): SourceSetDependent<DocumentationNode> =
+        getDocumentation()?.toSourceSetDependent() ?: emptyMap()
+
+    private fun ClassDescriptor.resolveClassDescriptionData(): ClassInfo {
         return ClassInfo(
             (getSuperInterfaces() + getAllSuperclassesWithoutAny()).map { DRI.from(it) },
-            resolveDescriptorData(platformData)
+            resolveDescriptorData()
         )
     }
 
@@ -520,9 +510,10 @@ private class DokkaDescriptorVisitor(
         DTypeParameter(
             DRI.from(this),
             name.identifier,
-            PlatformDependent.from(platformData, getDocumentation()),
+            resolveDescriptorData(),
+            null,
             upperBounds.map { it.toBound() },
-            listOf(platformData),
+            listOf(sourceSet),
             extra = PropertyContainer.withAll(additionalExtras())
         )
 
@@ -555,7 +546,7 @@ private class DokkaDescriptorVisitor(
 
     private fun DeclarationDescriptor.getDocumentation() = findKDoc().let {
         MarkdownParser(resolutionFacade, this, logger).parseFromKDocTag(it)
-    }
+    }.takeIf { it.children.isNotEmpty() }
 
     private fun ClassDescriptor.companion(dri: DRIWithPlatformInfo): DObject? = companionObjectDescriptor?.let {
         objectDescriptor(it, dri)
@@ -569,11 +560,8 @@ private class DokkaDescriptorVisitor(
         else -> KotlinModifier.Empty
     }
 
-    private fun MemberDescriptor.createSources(): PlatformDependent<DocumentableSource> = if (isExpect()) {
-        PlatformDependent(emptyMap(), DescriptorDocumentableSource(this))
-    } else {
-        PlatformDependent(mapOf(platformData to DescriptorDocumentableSource(this)))
-    }
+    private fun MemberDescriptor.createSources(): SourceSetDependent<DocumentableSource> =
+        DescriptorDocumentableSource(this).toSourceSetDependent()
 
     private fun FunctionDescriptor.additionalExtras() = listOfNotNull(
         ExtraModifiers.DYNAMIC.takeIf { isDynamic() },
@@ -634,7 +622,7 @@ private class DokkaDescriptorVisitor(
     private fun ValueParameterDescriptor.getDefaultValue(): String? =
         (source as? KotlinSourceElement)?.psi?.children?.find { it is KtExpression }?.text
 
-    private data class ClassInfo(val supertypes: List<DRI>, val docs: PlatformDependent<DocumentationNode>)
+    private data class ClassInfo(val supertypes: List<DRI>, val docs: SourceSetDependent<DocumentationNode>)
 
     private fun Visibility.toDokkaVisibility(): org.jetbrains.dokka.model.Visibility = when (this) {
         Visibilities.PUBLIC -> KotlinVisibility.Public
diff --git a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
index 439da560..232f6721 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import kotlin.reflect.KClass
 import kotlin.reflect.full.isSubclassOf
 
-private typealias GroupedTags = Map<KClass<out TagWrapper>, List<Pair<PlatformData?, TagWrapper>>>
+private typealias GroupedTags = Map<KClass<out TagWrapper>, List<Pair<SourceSetData?, TagWrapper>>>
 
 private val specialTags: Set<KClass<out TagWrapper>> =
     setOf(Property::class, Description::class, Constructor::class, Receiver::class, Param::class, See::class)
@@ -68,8 +68,8 @@ open class DefaultPageCreator(
             header(1) { text(m.name) }
         }
         +contentForComments(m)
-        block("Packages", 2, ContentKind.Packages, m.packages, m.platformData.toSet()) {
-            link(it.name, it.dri, kind = ContentKind.Main)
+        block("Packages", 2, ContentKind.Packages, m.packages, m.sourceSets.toSet()) {
+            link(it.name, it.dri)
         }
 //        text("Index\n") TODO
 //        text("Link to allpage here")
@@ -80,10 +80,10 @@ open class DefaultPageCreator(
             header(1) { text("Package ${p.name}") }
         }
         +contentForComments(p)
-        +contentForScope(p, p.dri, p.platformData)
-        block("Type aliases", 2, ContentKind.TypeAliases, p.typealiases, p.platformData.toSet()) {
+        +contentForScope(p, p.dri, p.sourceSets)
+        block("Type aliases", 2, ContentKind.TypeAliases, p.typealiases, p.sourceSets.toSet()) {
             link(it.name, it.dri, kind = ContentKind.Main)
-            platformDependentHint(it.dri, it.platformData.toSet(), kind = ContentKind.PlatformDependantHint) {
+            sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                 +buildSignature(it)
                 contentForBrief(it)
             }
@@ -93,47 +93,47 @@ open class DefaultPageCreator(
     protected open fun contentForScope(
         s: WithScope,
         dri: DRI,
-        platformData: List<PlatformData>
+        sourceSets: List<SourceSetData>
     ) = contentBuilder.contentFor(s as Documentable) {
-        block("Types", 2, ContentKind.Classlikes, s.classlikes, platformData.toSet()) {
+        block("Types", 2, ContentKind.Classlikes, s.classlikes, sourceSets.toSet()) {
             link(it.name ?: "", it.dri, kind = ContentKind.Main)
-            platformDependentHint(it.dri, it.platformData.toSet(), kind = ContentKind.PlatformDependantHint) {
+            sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                 +buildSignature(it)
                 contentForBrief(it)
             }
         }
-        block("Functions", 2, ContentKind.Functions, s.functions, platformData.toSet()) {
+        block("Functions", 2, ContentKind.Functions, s.functions, sourceSets.toSet()) {
             link(it.name, it.dri, kind = ContentKind.Main)
-            platformDependentHint(it.dri, it.platformData.toSet(), kind = ContentKind.PlatformDependantHint) {
+            sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                 +buildSignature(it)
                 contentForBrief(it)
             }
         }
-        block("Properties", 2, ContentKind.Properties, s.properties, platformData.toSet()) {
+        block("Properties", 2, ContentKind.Properties, s.properties, sourceSets.toSet()) {
             link(it.name, it.dri, kind = ContentKind.Main)
-            platformDependentHint(it.dri, it.platformData.toSet(), kind = ContentKind.PlatformDependantHint) {
+            sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                 +buildSignature(it)
 
                 contentForBrief(it)
             }
         }
         s.safeAs<WithExtraProperties<Documentable>>()?.let { it.extra[InheritorsInfo] }?.let { inheritors ->
-            val map = inheritors.value.map.filter { it.value.isNotEmpty() }
+            val map = inheritors.value.filter { it.value.isNotEmpty() }
             if (map.values.any()) {
                 header(2) { text("Inheritors") }
                 +ContentTable(
                     emptyList(),
                     map.entries.flatMap { entry -> entry.value.map { Pair(entry.key, it) } }
                         .groupBy({ it.second }, { it.first }).map { (classlike, platforms) ->
-                        buildGroup(dri, platforms.toSet(), ContentKind.Inheritors) {
-                            link(
-                                classlike.classNames?.substringBeforeLast(".") ?: classlike.toString()
-                                    .also { logger.warn("No class name found for DRI $classlike") }, classlike
-                            )
-                        }
-                    },
+                            buildGroup(dri, platforms.toSet(), ContentKind.Inheritors) {
+                                link(
+                                    classlike.classNames?.substringBeforeLast(".") ?: classlike.toString()
+                                        .also { logger.warn("No class name found for DRI $classlike") }, classlike
+                                )
+                            }
+                        },
                     DCI(setOf(dri), ContentKind.Inheritors),
-                    platformData.toSet(),
+                    sourceSets.toSet(),
                     style = emptySet()
                 )
             }
@@ -146,13 +146,13 @@ open class DefaultPageCreator(
             +buildSignature(e)
         }
         +contentForComments(e)
-        +contentForScope(e, e.dri, e.platformData)
+        +contentForScope(e, e.dri, e.sourceSets)
     }
 
     protected open fun contentForClasslike(c: DClasslike) = contentBuilder.contentFor(c) {
         group(kind = ContentKind.Cover) {
             header(1) { text(c.name.orEmpty()) }
-            platformDependentHint(c.dri, c.platformData.toSet()) {
+            sourceSetDependentHint(c.dri, c.sourceSets.toSet()) {
                 +buildSignature(c)
             }
         }
@@ -164,58 +164,57 @@ open class DefaultPageCreator(
                 2,
                 ContentKind.Constructors,
                 c.constructors.filter { it.extra[PrimaryConstructorExtra] == null },
-                c.platformData.toSet()
+                c.sourceSets.toSet()
             ) {
                 link(it.name, it.dri, kind = ContentKind.Main)
-                platformDependentHint(it.dri, it.platformData.toSet(), kind = ContentKind.PlatformDependantHint) {
+                sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                     +buildSignature(it)
                     contentForBrief(it)
                 }
             }
         }
         if (c is DEnum) {
-            block("Entries", 2, ContentKind.Classlikes, c.entries, c.platformData.toSet()) {
+            block("Entries", 2, ContentKind.Classlikes, c.entries, c.sourceSets.toSet()) {
                 link(it.name, it.dri, kind = ContentKind.Main)
-                platformDependentHint(it.dri, it.platformData.toSet(), kind = ContentKind.PlatformDependantHint) {
+                sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                     +buildSignature(it)
                     contentForBrief(it)
                 }
             }
         }
 
-        +contentForScope(c, c.dri, c.platformData)
+        +contentForScope(c, c.dri, c.sourceSets)
     }
 
     @Suppress("UNCHECKED_CAST")
-    private inline fun <reified T : TagWrapper> GroupedTags.withTypeUnnamed(): PlatformDependent<T> =
-        (this[T::class] as List<Pair<PlatformData, T>>?)
-            ?.let { PlatformDependent.from(it) }.orEmpty()
+    private inline fun <reified T : TagWrapper> GroupedTags.withTypeUnnamed(): SourceSetDependent<T> =
+        (this[T::class] as List<Pair<SourceSetData, T>>?)?.toMap().orEmpty()
 
     @Suppress("UNCHECKED_CAST")
-    private inline fun <reified T : NamedTagWrapper> GroupedTags.withTypeNamed(): Map<String, PlatformDependent<T>> =
-        (this[T::class] as List<Pair<PlatformData, T>>?)
+    private inline fun <reified T : NamedTagWrapper> GroupedTags.withTypeNamed(): Map<String, SourceSetDependent<T>> =
+        (this[T::class] as List<Pair<SourceSetData, T>>?)
             ?.groupBy { it.second.name }
-            ?.mapValues { (_, v) -> PlatformDependent.from(v) }
+            ?.mapValues { (_, v) -> v.toMap() }
             .orEmpty()
 
     private inline fun <reified T : TagWrapper> GroupedTags.isNotEmptyForTag(): Boolean =
-            this[T::class]?.isNotEmpty() ?: false
+        this[T::class]?.isNotEmpty() ?: false
 
     protected open fun contentForComments(
         d: Documentable
     ): List<ContentNode> {
-        val tags: GroupedTags = d.documentation.allEntries.flatMap { (pd, doc) ->
-            doc.children.asSequence().map { pd to it }
+        val tags: GroupedTags = d.documentation.flatMap { (pd, doc) ->
+            doc.children.asSequence().map { pd to it }.toList()
         }.groupBy { it.second::class }
 
-        val platforms = d.platformData
+        val platforms = d.sourceSets
 
         fun DocumentableContentBuilder.contentForDescription() {
             val description = tags.withTypeUnnamed<Description>()
             if (description.any { it.value.root.children.isNotEmpty() }) {
                 platforms.forEach { platform ->
-                    description.getOrExpect(platform)?.also {
-                        group(platformData = setOf(platform)) {
+                    description[platform]?.also {
+                        group(sourceSets = setOf(platform)) {
                             comment(it.root)
                         }
                     }
@@ -232,16 +231,16 @@ open class DefaultPageCreator(
                 }
                 table(kind = ContentKind.Parameters) {
                     platforms.flatMap { platform ->
-                        val receiverRow = receiver.getOrExpect(platform)?.let {
-                            buildGroup(platformData = setOf(platform), kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.KeyValue) {
+                        val receiverRow = receiver[platform]?.let {
+                            buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.KeyValue) {
                                 text("<receiver>")
                                 comment(it.root)
                             }
                         }
 
                         val paramRows = params.mapNotNull { (_, param) ->
-                            param.getOrExpect(platform)?.let {
-                                buildGroup(platformData = setOf(platform), kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.KeyValue) {
+                            param[platform]?.let {
+                                buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.KeyValue) {
                                     text(it.name, kind = ContentKind.Parameters)
                                     comment(it.root)
                                 }
@@ -263,8 +262,8 @@ open class DefaultPageCreator(
                 table(kind = ContentKind.Sample) {
                     platforms.flatMap { platform ->
                         seeAlsoTags.mapNotNull { (_, see) ->
-                            see.getOrExpect(platform)?.let {
-                                buildGroup(platformData = setOf(platform), kind = ContentKind.Comment, styles = mainStyles + ContentStyle.KeyValue) {
+                            see[platform]?.let {
+                                buildGroup(sourceSets = setOf(platform), kind = ContentKind.Comment, styles = mainStyles + ContentStyle.KeyValue) {
                                     if (it.address != null) link(it.name, it.address!!, kind = ContentKind.Comment)
                                     else text(it.name, kind = ContentKind.Comment)
                                     comment(it.root)
@@ -282,7 +281,7 @@ open class DefaultPageCreator(
                 platforms.forEach { platformData ->
                     val content = samples.filter { it.value.isEmpty() || platformData in it.value }
                     if (content.isNotEmpty()) {
-                        group(platformData = setOf(platformData)) {
+                        group(sourceSets = setOf(platformData)) {
                             header(4, kind = ContentKind.Comment) { text("Samples") }
                             content.forEach {
                                 comment(Text(it.key))
@@ -294,13 +293,13 @@ open class DefaultPageCreator(
         }
 
         fun DocumentableContentBuilder.contentForUnnamedTags() {
-            val unnamedTags: List<PlatformDependent<TagWrapper>> =
+            val unnamedTags: List<SourceSetDependent<TagWrapper>> =
                 tags.filterNot { (k, _) -> k.isSubclassOf(NamedTagWrapper::class) || k in specialTags }
-                    .map { (_, v) -> PlatformDependent.from(v) }
+                    .map { (_, v) -> v.mapNotNull { (k,v) -> k?.let { it to v } }.toMap() }
             platforms.forEach { platform ->
                 unnamedTags.forEach { pdTag ->
-                    pdTag.getOrExpect(platform)?.also { tag ->
-                        group(platformData = setOf(platform)) {
+                    pdTag[platform]?.also { tag ->
+                        group(sourceSets = setOf(platform)) {
                             header(4) { text(tag.toHeaderString()) }
                             comment(tag.root)
                         }
@@ -312,7 +311,7 @@ open class DefaultPageCreator(
         return contentBuilder.contentFor(d) {
             if (tags.isNotEmpty()) {
                 header(3) { text("Description") }
-                platformDependentHint(platformData = platforms.toSet()) {
+                sourceSetDependentHint(sourceSets = platforms.toSet()) {
                     contentForDescription()
                     contentForSamples()
                     contentForParams()
@@ -324,11 +323,11 @@ open class DefaultPageCreator(
     }
 
     protected open fun DocumentableContentBuilder.contentForBrief(content: Documentable) {
-        content.platformData.forEach { platform ->
+        content.sourceSets.forEach { platform ->
             val root = content.documentation[platform]?.children?.firstOrNull()?.root
 
             root?.let {
-                group(platformData = setOf(platform), kind = ContentKind.BriefComment) {
+                group(sourceSets = setOf(platform), kind = ContentKind.BriefComment) {
                     text(it.docTagSummary(), kind = ContentKind.Comment)
                 }
             }
@@ -338,7 +337,7 @@ open class DefaultPageCreator(
     protected open fun contentForFunction(f: DFunction) = contentBuilder.contentFor(f) {
         group(kind = ContentKind.Cover) {
             header(1) { text(f.name) }
-            platformDependentHint(f.dri, f.platformData.toSet()) {
+            sourceSetDependentHint(f.dri, f.sourceSets.toSet()) {
                 +buildSignature(f)
             }
         }
diff --git a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
index 6cb47b7f..3ed19afa 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
@@ -19,46 +19,46 @@ open class PageContentBuilder(
 ) {
     fun contentFor(
         dri: DRI,
-        platformData: Set<PlatformData>,
+        sourceSets: Set<SourceSetData>,
         kind: Kind = ContentKind.Main,
         styles: Set<Style> = emptySet(),
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
         block: DocumentableContentBuilder.() -> Unit
     ): ContentGroup =
-        DocumentableContentBuilder(dri, platformData, styles, extra)
+        DocumentableContentBuilder(dri, sourceSets, styles, extra)
             .apply(block)
-            .build(platformData, kind, styles, extra)
+            .build(sourceSets, kind, styles, extra)
 
     fun contentFor(
         d: Documentable,
         kind: Kind = ContentKind.Main,
         styles: Set<Style> = emptySet(),
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
-        platformData: Set<PlatformData> = d.platformData.toSet(),
+        sourceSets: Set<SourceSetData> = d.sourceSets.toSet(),
         block: DocumentableContentBuilder.() -> Unit = {}
     ): ContentGroup =
-        DocumentableContentBuilder(d.dri, platformData, styles, extra)
+        DocumentableContentBuilder(d.dri, sourceSets, styles, extra)
             .apply(block)
-            .build(platformData, kind, styles, extra)
+            .build(sourceSets, kind, styles, extra)
 
     @ContentBuilderMarker
     open inner class DocumentableContentBuilder(
         val mainDRI: DRI,
-        val mainPlatformData: Set<PlatformData>,
+        val mainPlatformData: Set<SourceSetData>,
         val mainStyles: Set<Style>,
         val mainExtra: PropertyContainer<ContentNode>
     ) {
         protected val contents = mutableListOf<ContentNode>()
 
         fun build(
-            platformData: Set<PlatformData>,
+            sourceSets: Set<SourceSetData>,
             kind: Kind,
             styles: Set<Style>,
             extra: PropertyContainer<ContentNode>
         ) = ContentGroup(
             contents.toList(),
             DCI(setOf(mainDRI), kind),
-            platformData,
+            sourceSets,
             styles,
             extra
         )
@@ -74,7 +74,7 @@ open class PageContentBuilder(
         fun header(
             level: Int,
             kind: Kind = ContentKind.Main,
-            platformData: Set<PlatformData> = mainPlatformData,
+            platformData: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit
@@ -88,11 +88,11 @@ open class PageContentBuilder(
         fun text(
             text: String,
             kind: Kind = ContentKind.Main,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
-            contents += createText(text, kind, platformData, styles, extra)
+            contents += createText(text, kind, sourceSets, styles, extra)
         }
 
         fun buildSignature(d: Documentable) = signatureProvider.signature(d)
@@ -100,26 +100,26 @@ open class PageContentBuilder(
         fun linkTable(
             elements: List<DRI>,
             kind: Kind = ContentKind.Main,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
             contents += ContentTable(
                 emptyList(),
                 elements.map {
-                    contentFor(it, platformData, kind, styles, extra) {
+                    contentFor(it, sourceSets, kind, styles, extra) {
                         link(it.classNames ?: "", it)
                     }
                 },
                 DCI(setOf(mainDRI), kind),
-                platformData, styles, extra
+                sourceSets, styles, extra
             )
         }
 
         fun table(
             dri: DRI = mainDRI,
             kind: Kind = ContentKind.Main,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             operation: DocumentableContentBuilder.() -> List<ContentGroup>
@@ -128,7 +128,7 @@ open class PageContentBuilder(
                 emptyList(),
                 operation(),
                 DCI(setOf(mainDRI), kind),
-                platformData, styles, extra
+                sourceSets, styles, extra
             )
         }
 
@@ -137,7 +137,7 @@ open class PageContentBuilder(
             level: Int,
             kind: Kind = ContentKind.Main,
             elements: Iterable<T>,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             renderWhenEmpty: Boolean = false,
@@ -148,12 +148,12 @@ open class PageContentBuilder(
                 contents += ContentTable(
                     emptyList(),
                     elements.map {
-                        buildGroup(it.dri, it.platformData.toSet(), kind, styles, extra) {
+                        buildGroup(it.dri, it.sourceSets.toSet(), kind, styles, extra) {
                             operation(it)
                         }
                     },
                     DCI(setOf(mainDRI), kind),
-                    platformData, styles, extra
+                    sourceSets, styles, extra
                 )
             }
         }
@@ -163,17 +163,17 @@ open class PageContentBuilder(
             prefix: String = "",
             suffix: String = "",
             separator: String = ", ",
-            platformData: Set<PlatformData> = mainPlatformData, // TODO: children should be aware of this platform data
+            sourceSets: Set<SourceSetData> = mainPlatformData, // TODO: children should be aware of this platform data
             operation: DocumentableContentBuilder.(T) -> Unit
         ) {
             if (elements.isNotEmpty()) {
-                if (prefix.isNotEmpty()) text(prefix, platformData = platformData)
+                if (prefix.isNotEmpty()) text(prefix, sourceSets = sourceSets)
                 elements.dropLast(1).forEach {
                     operation(it)
-                    text(separator, platformData = platformData)
+                    text(separator, sourceSets = sourceSets)
                 }
                 operation(elements.last())
-                if (suffix.isNotEmpty()) text(suffix, platformData = platformData)
+                if (suffix.isNotEmpty()) text(suffix, sourceSets = sourceSets)
             }
         }
 
@@ -181,15 +181,15 @@ open class PageContentBuilder(
             text: String,
             address: DRI,
             kind: Kind = ContentKind.Main,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
             contents += ContentDRILink(
-                listOf(createText(text, kind, platformData, styles, extra)),
+                listOf(createText(text, kind, sourceSets, styles, extra)),
                 address,
                 DCI(setOf(mainDRI), kind),
-                platformData
+                sourceSets
             )
         }
 
@@ -197,99 +197,99 @@ open class PageContentBuilder(
             text: String,
             address: String,
             kind: Kind = ContentKind.Main,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) =
         ContentResolvedLink(
-            children = listOf(createText(text, kind, platformData, styles, extra)),
+            children = listOf(createText(text, kind, sourceSets, styles, extra)),
             address = address,
             extra = PropertyContainer.empty(),
             dci = DCI(setOf(mainDRI), kind),
-            platforms = platformData,
+            sourceSets = sourceSets,
             style = emptySet()
         )
 
         fun link(
             address: DRI,
             kind: Kind = ContentKind.Main,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit
         ) {
             contents += ContentDRILink(
-                contentFor(mainDRI, platformData, kind, styles, extra, block).children,
+                contentFor(mainDRI, sourceSets, kind, styles, extra, block).children,
                 address,
                 DCI(setOf(mainDRI), kind),
-                platformData
+                sourceSets
             )
         }
 
         fun comment(
             docTag: DocTag,
             kind: Kind = ContentKind.Comment,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
             val content = commentsConverter.buildContent(
                 docTag,
                 DCI(setOf(mainDRI), kind),
-                platformData
+                sourceSets
             )
-            contents += ContentGroup(content, DCI(setOf(mainDRI), kind), platformData, styles, extra)
+            contents += ContentGroup(content, DCI(setOf(mainDRI), kind), sourceSets, styles, extra)
         }
 
         fun group(
             dri: DRI = mainDRI,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit
         ) {
-            contents += buildGroup(dri, platformData, kind, styles, extra, block)
+            contents += buildGroup(dri, sourceSets, kind, styles, extra, block)
         }
 
         fun buildGroup(
             dri: DRI = mainDRI,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit
-        ): ContentGroup = contentFor(dri, platformData, kind, styles, extra, block)
+        ): ContentGroup = contentFor(dri, sourceSets, kind, styles, extra, block)
 
-        fun platformDependentHint(
+        fun sourceSetDependentHint(
             dri: DRI = mainDRI,
-            platformData: Set<PlatformData> = mainPlatformData,
+            sourceSets: Set<SourceSetData> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit
         ) {
             contents += PlatformHintedContent(
-                buildGroup(dri, platformData, kind, styles, extra, block),
-                platformData
+                buildGroup(dri, sourceSets, kind, styles, extra, block),
+                sourceSets
             )
         }
 
         protected fun createText(
             text: String,
             kind: Kind,
-            platformData: Set<PlatformData>,
+            sourceSets: Set<SourceSetData>,
             styles: Set<Style>,
             extra: PropertyContainer<ContentNode>
         ) =
-            ContentText(text, DCI(setOf(mainDRI), kind), platformData, styles, extra)
+            ContentText(text, DCI(setOf(mainDRI), kind), sourceSets, styles, extra)
 
         fun <T> platformText(
-            value: PlatformDependent<T>,
-            platforms: Set<PlatformData> = value.keys,
+            value: SourceSetDependent<T>,
+            platforms: Set<SourceSetData> = value.keys,
             transform: (T) -> String
         ) = value.entries.filter { it.key in platforms }.forEach { (p, v) ->
-            transform(v).takeIf { it.isNotBlank() }?.also { text(it, platformData = setOf(p)) }
+            transform(v).takeIf { it.isNotBlank() }?.also { text(it, sourceSets = setOf(p)) }
         }
     }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
index e5fa4bfc..ca8055c8 100644
--- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
@@ -9,7 +9,6 @@ import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.withClass
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.sources.SourceToDocumentableTranslator
 import org.jetbrains.dokka.utilities.DokkaLogger
@@ -23,16 +22,21 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.psiUtil.getChildOfType
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
+import java.io.File
 
 object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
 
-    override fun invoke(platformData: PlatformData, context: DokkaContext): DModule {
+    override fun invoke(sourceSetData: SourceSetData, context: DokkaContext): DModule {
 
-        val (environment, _) = context.platforms.getValue(platformData)
+        fun isFileInSourceRoots(file: File) : Boolean {
+            return sourceSetData.sourceRoots.any { root -> file.path.startsWith(File(root.path).absolutePath) }
+        }
+
+        val (environment, _) = context.platforms.getValue(sourceSetData)
 
         val sourceRoots = environment.configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
             ?.filterIsInstance<JavaSourceRoot>()
-            ?.map { it.file }
+            ?.mapNotNull { it.file.takeIf(::isFileInSourceRoots) }
             ?: listOf()
         val localFileSystem = VirtualFileManager.getInstance().getFileSystem("file")
 
@@ -46,11 +50,11 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
 
         val docParser =
             DokkaPsiParser(
-                platformData,
+                sourceSetData,
                 context.logger
             )
         return DModule(
-            platformData.name,
+            sourceSetData.moduleName,
             psiFiles.mapNotNull { it.safeAs<PsiJavaFile>() }.groupBy { it.packageName }.map { (packageName, psiFiles) ->
                 val dri = DRI(packageName = packageName)
                 DPackage(
@@ -61,17 +65,19 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                         psiFile.classes.map { docParser.parseClasslike(it, dri) }
                     },
                     emptyList(),
-                    PlatformDependent.empty(),
-                    listOf(platformData)
+                    emptyMap(),
+                    null,
+                    listOf(sourceSetData)
                 )
             },
-            PlatformDependent.empty(),
-            listOf(platformData)
+            emptyMap(),
+            null,
+            listOf(sourceSetData)
         )
     }
 
     class DokkaPsiParser(
-        private val platformData: PlatformData,
+        private val sourceSetData: SourceSetData,
         private val logger: DokkaLogger
     ) {
 
@@ -104,7 +110,7 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
         }
 
         private fun <T> T.toPlatformDependant() =
-            PlatformDependent(mapOf(platformData to this))
+            mapOf(sourceSetData to this)
 
         fun parseClasslike(psi: PsiClass, parent: DRI): DClasslike = with(psi) {
             val dri = parent.withClass(name.toString())
@@ -145,6 +151,7 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                         name.orEmpty(),
                         dri,
                         documentation,
+                        null,
                         source,
                         allFunctions,
                         fields.mapNotNull { parseField(it, accessors[it].orEmpty()) },
@@ -152,7 +159,7 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                         visibility,
                         null,
                         constructors.map { parseFunction(it, true) },
-                        listOf(platformData),
+                        listOf(sourceSetData),
                         PropertyContainer.empty<DAnnotation>() + annotations.toList().toExtra()
                     )
                 isEnum -> DEnum(
@@ -163,14 +170,16 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                             dri.withClass("$name.${entry.name}"),
                             entry.name.orEmpty(),
                             javadocParser.parseDocumentation(entry).toPlatformDependant(),
+                            null,
                             emptyList(),
                             emptyList(),
                             emptyList(),
-                            listOf(platformData),
+                            listOf(sourceSetData),
                             PropertyContainer.empty<DEnumEntry>() + entry.annotations.toList().toExtra()
                         )
                     },
                     documentation,
+                    null,
                     source,
                     allFunctions,
                     fields.filter { it !is PsiEnumConstant }.map { parseField(it, accessors[it].orEmpty()) },
@@ -179,13 +188,14 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                     null,
                     constructors.map { parseFunction(it, true) },
                     ancestors,
-                    listOf(platformData),
+                    listOf(sourceSetData),
                     PropertyContainer.empty<DEnum>() + annotations.toList().toExtra()
                 )
                 isInterface -> DInterface(
                     dri,
                     name.orEmpty(),
                     documentation,
+                    null,
                     source,
                     allFunctions,
                     fields.mapNotNull { parseField(it, accessors[it].orEmpty()) },
@@ -194,7 +204,7 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                     null,
                     mapTypeParameters(dri),
                     ancestors,
-                    listOf(platformData),
+                    listOf(sourceSetData),
                     PropertyContainer.empty<DInterface>() + annotations.toList().toExtra()
                 )
                 else -> DClass(
@@ -210,8 +220,9 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                     mapTypeParameters(dri),
                     ancestors,
                     documentation,
+                    null,
                     modifiers,
-                    listOf(platformData),
+                    listOf(sourceSetData),
                     PropertyContainer.empty<DClass>() + annotations.toList().toExtra()
                 )
             }
@@ -232,18 +243,20 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                         dri.copy(target = index + 1),
                         psiParameter.name,
                         javadocParser.parseDocumentation(psiParameter).toPlatformDependant(),
+                        null,
                         getBound(psiParameter.type),
-                        listOf(platformData)
+                        listOf(sourceSetData)
                     )
                 },
                 javadocParser.parseDocumentation(psi).toPlatformDependant(),
+                null,
                 PsiDocumentableSource(psi).toPlatformDependant(),
                 psi.getVisibility().toPlatformDependant(),
                 psi.returnType?.let { getBound(type = it) } ?: Void,
                 psi.mapTypeParameters(dri),
                 null,
                 psi.getModifier().toPlatformDependant(),
-                listOf(platformData),
+                listOf(sourceSetData),
                 PropertyContainer.withAll(
                     InheritedFunction(isInherited),
                     psi.annotations.toList().toExtra(),
@@ -313,8 +326,9 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                     dri.copy(genericTarget = index),
                     type.name.orEmpty(),
                     javadocParser.parseDocumentation(type).toPlatformDependant(),
+                    null,
                     mapBounds(type.bounds),
-                    listOf(platformData)
+                    listOf(sourceSetData)
                 )
             }
         }
@@ -349,6 +363,7 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                 dri,
                 psi.name!!, // TODO: Investigate if this is indeed nullable
                 javadocParser.parseDocumentation(psi).toPlatformDependant(),
+                null,
                 PsiDocumentableSource(psi).toPlatformDependant(),
                 psi.getVisibility().toPlatformDependant(),
                 getBound(psi.type),
@@ -356,7 +371,7 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                 accessors.firstOrNull { it.hasParameters() }?.let { parseFunction(it) },
                 accessors.firstOrNull { it.returnType == psi.type }?.let { parseFunction(it) },
                 psi.getModifier().toPlatformDependant(),
-                listOf(platformData),
+                listOf(sourceSetData),
                 emptyList(),
                 PropertyContainer.empty<DProperty>() + psi.annotations.toList().toExtra()
             )
diff --git a/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt b/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
index ef97b04c..3b69a54e 100644
--- a/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
+++ b/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
@@ -17,7 +17,7 @@ abstract class AbstractExpectTest(
             format = outFormat
             passes {
                 pass {
-                    sourceRoots = listOf(path.asString())
+                    sourceRoots = listOf(path.toAbsolutePath().asString())
                 }
             }
         }
diff --git a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
index bf1d52d8..1299bf80 100644
--- a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
+++ b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
@@ -29,6 +29,7 @@ class LinkableContentTest : AbstractCoreTest() {
                     sourceRoots = listOf("jsMain", "commonMain", "jvmAndJsSecondCommonMain").map {
                         "$testDataDir/$it/kotlin"
                     }
+                    sourceSetName = "js"
                     includes = listOf("$includesDir/include2.md")
                 }
                 pass {
@@ -38,6 +39,7 @@ class LinkableContentTest : AbstractCoreTest() {
                     sourceRoots = listOf("jvmMain", "commonMain", "jvmAndJsSecondCommonMain").map {
                         "$testDataDir/$it/kotlin"
                     }
+                    sourceSetName = "jvm"
                     includes = listOf("$includesDir/include1.md")
                 }
             }
@@ -73,6 +75,7 @@ class LinkableContentTest : AbstractCoreTest() {
                             lineSuffix = "#L"
                         )
                     )
+                    sourceSetName = "js"
                 }
                 pass {
                     moduleName = "example"
@@ -86,6 +89,7 @@ class LinkableContentTest : AbstractCoreTest() {
                             lineSuffix = "#L"
                         )
                     )
+                    sourceSetName = "jvm"
                 }
             }
         }
@@ -129,6 +133,7 @@ class LinkableContentTest : AbstractCoreTest() {
                     analysisPlatform = "js"
                     targets = listOf("js")
                     sourceRoots = listOf("$testDataDir/jsMain/kotlin")
+                    sourceSetName = "js"
                     samples = listOf("$testDataDir/jsMain/resources/Samples.kt")
                 }
                 pass {
@@ -136,6 +141,7 @@ class LinkableContentTest : AbstractCoreTest() {
                     analysisPlatform = "jvm"
                     targets = listOf("jvm")
                     sourceRoots = listOf("$testDataDir/jvmMain/kotlin")
+                    sourceSetName = "jvm"
                     samples = listOf("$testDataDir/jvmMain/resources/Samples.kt")
                 }
             }
diff --git a/plugins/base/src/test/kotlin/model/ClassesTest.kt b/plugins/base/src/test/kotlin/model/ClassesTest.kt
index ee109ba1..a349e54a 100644
--- a/plugins/base/src/test/kotlin/model/ClassesTest.kt
+++ b/plugins/base/src/test/kotlin/model/ClassesTest.kt
@@ -1,9 +1,7 @@
 package model
 
-import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.KotlinModifier.*
-import org.jetbrains.dokka.pages.PlatformData
 import org.junit.jupiter.api.Assertions.assertNull
 import org.junit.jupiter.api.Test
 import utils.AbstractModelTest
@@ -169,7 +167,7 @@ class ClassesTest : AbstractModelTest("/src/main/kotlin/classes/Test.kt", "class
         ) {
             with((this / "classes" / "Klass").cast<DClass>()) {
                 name equals "Klass"
-                modifier.allValues.forEach { it equals Sealed }
+                modifier.values.forEach { it equals Sealed }
             }
         }
     }
@@ -211,15 +209,15 @@ class ClassesTest : AbstractModelTest("/src/main/kotlin/classes/Test.kt", "class
             val D = (this / "classes" / "D").cast<DClass>()
 
             with(C) {
-                modifier.allValues.forEach { it equals Open }
+                modifier.values.forEach { it equals Open }
                 with((this / "f").cast<DFunction>()) {
-                    modifier.allValues.forEach { it equals Open }
+                    modifier.values.forEach { it equals Open }
                 }
             }
             with(D) {
-                modifier.allValues.forEach { it equals Final }
+                modifier.values.forEach { it equals Final }
                 with((this / "f").cast<DFunction>()) {
-                    modifier.allValues.forEach { it equals Open }
+                    modifier.values.forEach { it equals Open }
                 }
                 D.supertypes.flatMap { it.component2() }.firstOrNull() equals C.dri
             }
@@ -246,16 +244,16 @@ class ClassesTest : AbstractModelTest("/src/main/kotlin/classes/Test.kt", "class
             val E = (this / "classes" / "E").cast<DClass>()
 
             with(C) {
-                modifier.allValues.forEach { it equals Abstract }
-                ((this / "foo").cast<DFunction>()).modifier.allValues.forEach { it equals Abstract }
+                modifier.values.forEach { it equals Abstract }
+                ((this / "foo").cast<DFunction>()).modifier.values.forEach { it equals Abstract }
             }
 
             with(D) {
-                modifier.allValues.forEach { it equals Abstract }
+                modifier.values.forEach { it equals Abstract }
             }
 
             with(E) {
-                modifier.allValues.forEach { it equals Final }
+                modifier.values.forEach { it equals Final }
 
             }
             D.supers.firstOrNull() equals C.dri
diff --git a/plugins/base/src/test/kotlin/model/InheritorsTest.kt b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
index ee445b5d..ce8a87ca 100644
--- a/plugins/base/src/test/kotlin/model/InheritorsTest.kt
+++ b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
@@ -30,8 +30,8 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
             pluginsOverrides = listOf(InheritorsPlugin)
         ) {
             with((this / "inheritors" / "A").cast<DInterface>()) {
-                val map = extra[InheritorsInfo].assertNotNull("InheritorsInfo").value.map
-                with(map.keys.also { it counts 1 }.find { it.platformType == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }
+                val map = extra[InheritorsInfo].assertNotNull("InheritorsInfo").value
+                with(map.keys.also { it counts 1 }.find { it.platform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }
                 ) {
                     this counts 1
                     first().classNames equals "B"
@@ -77,13 +77,13 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
         ) {
             documentablesTransformationStage = { m ->
                 with((m / "inheritors" / "A").cast<DInterface>()) {
-                    val map = extra[InheritorsInfo].assertNotNull("InheritorsInfo").value.map
+                    val map = extra[InheritorsInfo].assertNotNull("InheritorsInfo").value
                     with(map.keys.also { it counts 2 }) {
-                        with(find { it.platformType == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }) {
+                        with(find { it.platform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }) {
                             this counts 1
                             first().classNames equals "B"
                         }
-                        with(find { it.platformType == Platform.js }.assertNotNull("js key").let { map[it]!! }) {
+                        with(find { it.platform == Platform.js }.assertNotNull("js key").let { map[it]!! }) {
                             this counts 2
                             val classes = listOf("B", "C")
                             assertTrue(all { classes.contains(it.classNames) }, "One of subclasses missing in js" )
diff --git a/plugins/base/src/test/kotlin/model/JavaTest.kt b/plugins/base/src/test/kotlin/model/JavaTest.kt
index 20543c8f..a58b380c 100644
--- a/plugins/base/src/test/kotlin/model/JavaTest.kt
+++ b/plugins/base/src/test/kotlin/model/JavaTest.kt
@@ -112,7 +112,7 @@ class JavaTest : AbstractModelTest("/src/main/kotlin/java/Test.java", "java") {
             with((this / "java" / "Foo").cast<DClass>()) {
                 val sups = listOf("Exception", "Cloneable")
                 assertTrue(
-                    sups.all { s -> supertypes.map.values.flatten().any { it.classNames == s } })
+                    sups.all { s -> supertypes.values.flatten().any { it.classNames == s } })
                 "Foo must extend ${sups.joinToString(", ")}"
             }
         }
@@ -410,7 +410,7 @@ class JavaTest : AbstractModelTest("/src/main/kotlin/java/Test.java", "java") {
                 val dri = (this / "Bar").assertNotNull("Foo dri").dri
                 with((this / "Foo").cast<DClass>()) {
                     with(extra[InheritorsInfo].assertNotNull("InheritorsInfo")) {
-                        with(value.map.values.flatten().distinct()) {
+                        with(value.values.flatten().distinct()) {
                             this counts 1
                             first() equals dri
                         }
diff --git a/plugins/base/src/test/kotlin/model/PackagesTest.kt b/plugins/base/src/test/kotlin/model/PackagesTest.kt
index 11d456ce..676f034a 100644
--- a/plugins/base/src/test/kotlin/model/PackagesTest.kt
+++ b/plugins/base/src/test/kotlin/model/PackagesTest.kt
@@ -14,8 +14,8 @@ class PackagesTest : AbstractModelTest("/src/main/kotlin/packages/Test.kt", "pac
             """.trimIndent(),
             prependPackage = false
         ) {
-            with((this / "[jvm root]").cast<DPackage>()) {
-                name equals "[jvm root]"
+            with((this / "[main root]").cast<DPackage>()) {
+                name equals "[main root]"
                 children counts 0
             }
         }
diff --git a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
index 237f4fd9..dd4d1ee0 100644
--- a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
+++ b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
@@ -14,6 +14,8 @@ import org.jetbrains.dokka.base.transformers.pages.samples.DefaultSamplesTransfo
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.SourceSetCache
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -34,6 +36,7 @@ abstract class RenderingOnlyTestBase {
         DokkaBase().htmlPreprocessors to { _ -> RootCreator },
         DokkaBase().externalLocationProviderFactory to { _ -> ::JavadocExternalLocationProviderFactory },
         DokkaBase().externalLocationProviderFactory to { _ -> ::DokkaExternalLocationProviderFactory },
+        sourceSetCache = SourceSetCache(),
         testConfiguration = DokkaConfigurationImpl("", "", false, null, emptyList(), emptyList(), emptyList(), emptyMap())
     )
 
@@ -105,7 +108,7 @@ internal object EmptyCommentConverter : CommentsToContentConverter {
     override fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        platforms: Set<PlatformData>,
+        sourceSets: Set<SourceSetData>,
         styles: Set<Style>,
         extras: PropertyContainer<ContentNode>
     ): List<ContentNode> = emptyList()
@@ -113,7 +116,7 @@ internal object EmptyCommentConverter : CommentsToContentConverter {
 
 internal object EmptyLocationProviderFactory: LocationProviderFactory {
     override fun getLocationProvider(pageNode: RootPageNode) = object : LocationProvider {
-        override fun resolve(dri: DRI, platforms: List<PlatformData>, context: PageNode?): String = ""
+        override fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode?): String = ""
 
         override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String = node.name
 
diff --git a/plugins/base/src/test/kotlin/renderers/html/PlatformDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/PlatformDependentHintTest.kt
deleted file mode 100644
index cf1ac0a9..00000000
--- a/plugins/base/src/test/kotlin/renderers/html/PlatformDependentHintTest.kt
+++ /dev/null
@@ -1,120 +0,0 @@
-package renderers.html
-
-import org.jetbrains.dokka.Platform
-import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
-import org.jetbrains.dokka.pages.PlatformData
-import org.jetbrains.dokka.pages.TextStyle
-import org.junit.jupiter.api.Test
-import renderers.Div
-import renderers.RenderingOnlyTestBase
-import renderers.TestPage
-import renderers.match
-
-class PlatformDependentHintTest : RenderingOnlyTestBase() {
-    private val pl1 = PlatformData("pl1", Platform.js, listOf("pl1"))
-    private val pl2 = PlatformData("pl2", Platform.jvm, listOf("pl2"))
-    private val pl3 = PlatformData("pl3", Platform.native, listOf("pl3"))
-
-    @Test
-    fun platformIndependentCase() {
-        val page = TestPage {
-            platformDependentHint(platformData = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
-                text("a")
-                text("b")
-                text("c")
-            }
-        }
-
-        HtmlRenderer(context).render(page)
-        renderedContent.match(Div(Div(Div("abc"))))
-    }
-
-    @Test
-    fun completelyDivergentCase() {
-        val page = TestPage {
-            platformDependentHint(platformData = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
-                text("a", platformData = setOf(pl1))
-                text("b", platformData = setOf(pl2))
-                text("c", platformData = setOf(pl3))
-            }
-        }
-
-        HtmlRenderer(context).render(page)
-        renderedContent.match(Div(Div(Div("a")), Div(Div("b")), Div(Div("c"))))
-    }
-
-    @Test
-    fun overlappingCase() {
-        val page = TestPage {
-            platformDependentHint(platformData = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
-                text("a", platformData = setOf(pl1))
-                text("b", platformData = setOf(pl1, pl2))
-                text("c", platformData = setOf(pl2))
-            }
-        }
-
-        HtmlRenderer(context).render(page)
-        renderedContent.match(Div(Div(Div("ab")), Div(Div("bc"))))
-    }
-
-    @Test
-    fun caseThatCanBeSimplified() {
-        val page = TestPage {
-            platformDependentHint(platformData = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
-                text("a", platformData = setOf(pl1, pl2))
-                text("b", platformData = setOf(pl1))
-                text("b", platformData = setOf(pl2))
-            }
-        }
-
-        HtmlRenderer(context).render(page)
-        renderedContent.match(Div(Div(Div("ab"))))
-    }
-
-    @Test
-    fun caseWithGroupBreakingSimplification() {
-        val page = TestPage {
-            platformDependentHint(platformData = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
-                group(styles = setOf(TextStyle.Block)) {
-                    text("a", platformData = setOf(pl1, pl2))
-                    text("b", platformData = setOf(pl1))
-                }
-                text("b", platformData = setOf(pl2))
-            }
-        }
-
-        HtmlRenderer(context).render(page)
-        renderedContent.match(Div(Div(Div(Div("ab"))), Div(Div(Div("a"), "b"))))
-    }
-
-    @Test
-    fun caseWithGroupNotBreakingSimplification() {
-        val page = TestPage {
-            platformDependentHint(platformData = setOf(pl1, pl2)) {
-                group {
-                    text("a", platformData = setOf(pl1, pl2))
-                    text("b", platformData = setOf(pl1))
-                }
-                text("b", platformData = setOf(pl2))
-            }
-        }
-
-        HtmlRenderer(context).render(page)
-        println(renderedContent)
-        renderedContent.match(Div(Div("ab")))
-    }
-
-    @Test
-    fun partiallyUnifiedCase() {
-        val page = TestPage {
-            platformDependentHint(platformData = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
-                text("a", platformData = setOf(pl1))
-                text("a", platformData = setOf(pl2))
-                text("b", platformData = setOf(pl3))
-            }
-        }
-
-        HtmlRenderer(context).render(page)
-        renderedContent.match(Div(Div(Div("a")), Div(Div("b"))))
-    }
-}
\ No newline at end of file
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
new file mode 100644
index 00000000..f774a09b
--- /dev/null
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -0,0 +1,121 @@
+package renderers.html
+
+import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.SourceRootImpl
+import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
+import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.pages.TextStyle
+import org.junit.jupiter.api.Test
+import renderers.Div
+import renderers.RenderingOnlyTestBase
+import renderers.TestPage
+import renderers.match
+
+class SourceSetDependentHintTest : RenderingOnlyTestBase() {
+    private val pl1 = SourceSetData("root", "pl1", Platform.js, listOf(SourceRootImpl("pl1")))
+    private val pl2 = SourceSetData("root","pl2", Platform.jvm, listOf(SourceRootImpl("pl1")))
+    private val pl3 = SourceSetData("root","pl3", Platform.native, listOf(SourceRootImpl("pl1")))
+
+    @Test
+    fun platformIndependentCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a")
+                text("b")
+                text("c")
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("abc"))))
+    }
+
+    @Test
+    fun completelyDivergentCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl2))
+                text("c", sourceSets = setOf(pl3))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("a")), Div(Div("b")), Div(Div("c"))))
+    }
+
+    @Test
+    fun overlappingCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl1, pl2))
+                text("c", sourceSets = setOf(pl2))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("ab")), Div(Div("bc"))))
+    }
+
+    @Test
+    fun caseThatCanBeSimplified() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1, pl2))
+                text("b", sourceSets = setOf(pl1))
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("ab"))))
+    }
+
+    @Test
+    fun caseWithGroupBreakingSimplification() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2), styles = setOf(TextStyle.Block)) {
+                group(styles = setOf(TextStyle.Block)) {
+                    text("a", sourceSets = setOf(pl1, pl2))
+                    text("b", sourceSets = setOf(pl1))
+                }
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div(Div("ab"))), Div(Div(Div("a"), "b"))))
+    }
+
+    @Test
+    fun caseWithGroupNotBreakingSimplification() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2)) {
+                group {
+                    text("a", sourceSets = setOf(pl1, pl2))
+                    text("b", sourceSets = setOf(pl1))
+                }
+                text("b", sourceSets = setOf(pl2))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        println(renderedContent)
+        renderedContent.match(Div(Div("ab")))
+    }
+
+    @Test
+    fun partiallyUnifiedCase() {
+        val page = TestPage {
+            sourceSetDependentHint(sourceSets = setOf(pl1, pl2, pl3), styles = setOf(TextStyle.Block)) {
+                text("a", sourceSets = setOf(pl1))
+                text("a", sourceSets = setOf(pl2))
+                text("b", sourceSets = setOf(pl3))
+            }
+        }
+
+        HtmlRenderer(context).render(page)
+        renderedContent.match(Div(Div(Div("a")), Div(Div("b"))))
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/navigation.html b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/navigation.html
index 35fe78dc..29daddec 100644
--- a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//f/#//">
-      <div class="overview"><a href="root/[jvm root]/f.html">f</a></div>
+      <div class="overview"><a href="root/[main root]/f.html">f</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[jvm root]/f.html b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[jvm root]/f.html
deleted file mode 100644
index 6ca7daa7..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[jvm root]/f.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>f</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//f/#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="f.html">f</a></div>
-          <div class="cover ">
-            <h1>f</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[jvm root]/index.html
deleted file mode 100644
index d1b41977..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="f.html">f</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[main root]/f.html b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[main root]/f.html
new file mode 100644
index 00000000..8044ccbf
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[main root]/f.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>f</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//f/#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="f.html">f</a></div>
+          <div class="cover ">
+            <h1>f</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..9668ba81
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="f.html">f</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/index.html b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/package-list b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/package-list
index 8f1c5fd9..aed2a34c 100644
--- a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://f/#//root/[jvm root]/f.html
-[jvm root]
+$dokka.location://f/#//root/[main root]/f.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/annotatedFunction/out/html/scripts/pages.js b/plugins/base/src/test/resources/expect/annotatedFunction/out/html/scripts/pages.js
new file mode 100644
index 00000000..e69de29b
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/navigation.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/navigation.html
index a7486efc..0a2d2041 100644
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/navigation.html
@@ -1,12 +1,12 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-    <div class="sideMenuPart" id="nav-submenu-0-0" pageId="[jvm root]/Fancy////">
-      <div class="overview"><a href="root/[jvm root]/-fancy/index.html">Fancy</a></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+    <div class="sideMenuPart" id="nav-submenu-0-0" pageId="[main root]/Fancy////">
+      <div class="overview"><a href="root/[main root]/-fancy/index.html">Fancy</a></div>
     </div>
     <div class="sideMenuPart" id="nav-submenu-0-1" pageId="//f/#//">
-      <div class="overview"><a href="root/[jvm root]/f.html">f</a></div>
+      <div class="overview"><a href="root/[main root]/f.html">f</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/-init-.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/-init-.html
deleted file mode 100644
index 6e578700..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/-init-.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>&lt;init&gt;</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/Fancy/&lt;init&gt;/#kotlin.Int//">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a>/<a href="-init-.html">&lt;init&gt;</a></div>
-          <div class="cover ">
-            <h1>&lt;init&gt;</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="-init-.html">&lt;init&gt;</a>(size: <a href="">Int</a>)</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/equals.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/equals.html
deleted file mode 100644
index 52566473..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/equals.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>equals</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="/Fancy/equals/#kotlin.Any?//">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a>/<a href="equals.html">equals</a></div>
-          <div class="cover ">
-            <h1>equals</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">open fun <a href="equals.html">equals</a>(other: <a href="">Any</a>): <a href="">Boolean</a></div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/hash-code.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/hash-code.html
deleted file mode 100644
index 98338519..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/hash-code.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>hashCode</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="/Fancy/hashCode/#//">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a>/<a href="hash-code.html">hashCode</a></div>
-          <div class="cover ">
-            <h1>hashCode</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">open fun <a href="hash-code.html">hashCode</a>(): <a href="">Int</a></div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/index.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/index.html
deleted file mode 100644
index 6ff4bf1e..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/index.html	
+++ /dev/null
@@ -1,102 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>Fancy</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/Fancy////">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a></div>
-          <div class="cover ">
-            <h1>Fancy</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">annotation class <a href="index.html">Fancy</a></div></div></div>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="equals.html">equals</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">open fun <a href="equals.html">equals</a>(other: <a href="">Any</a>): <a href="">Boolean</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="hash-code.html">hashCode</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">open fun <a href="hash-code.html">hashCode</a>(): <a href="">Int</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="to-string.html">toString</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">open fun <a href="to-string.html">toString</a>(): <a href="">String</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-          <h2>Properties</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="">size</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final val <a href="">size</a>: <a href="">Int</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/to-string.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/to-string.html
deleted file mode 100644
index b64fcf93..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/-fancy/to-string.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>toString</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="/Fancy/toString/#//">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a>/<a href="to-string.html">toString</a></div>
-          <div class="cover ">
-            <h1>toString</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">open fun <a href="to-string.html">toString</a>(): <a href="">String</a></div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/f.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/f.html
deleted file mode 100644
index 6ca7daa7..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/f.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>f</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//f/#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="f.html">f</a></div>
-          <div class="cover ">
-            <h1>f</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 59652a6d..00000000
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,69 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Types</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="-fancy/index.html">Fancy</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">annotation class <a href="-fancy/index.html">Fancy</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="f.html">f</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/-init-.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/-init-.html
new file mode 100644
index 00000000..0ce13e70
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/-init-.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>&lt;init&gt;</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/Fancy/&lt;init&gt;/#kotlin.Int//">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a>/<a href="-init-.html">&lt;init&gt;</a></div>
+          <div class="cover ">
+            <h1>&lt;init&gt;</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="-init-.html">&lt;init&gt;</a>(size: <a href="">Int</a>)</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/equals.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/equals.html
new file mode 100644
index 00000000..5de2c68d
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/equals.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>equals</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="/Fancy/equals/#kotlin.Any?//">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a>/<a href="equals.html">equals</a></div>
+          <div class="cover ">
+            <h1>equals</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">open fun <a href="equals.html">equals</a>(other: <a href="">Any</a>): <a href="">Boolean</a></div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/hash-code.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/hash-code.html
new file mode 100644
index 00000000..675c156f
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/hash-code.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>hashCode</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="/Fancy/hashCode/#//">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a>/<a href="hash-code.html">hashCode</a></div>
+          <div class="cover ">
+            <h1>hashCode</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">open fun <a href="hash-code.html">hashCode</a>(): <a href="">Int</a></div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/index.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/index.html
new file mode 100644
index 00000000..984c084b
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/index.html	
@@ -0,0 +1,102 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>Fancy</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/Fancy////">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a></div>
+          <div class="cover ">
+            <h1>Fancy</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">annotation class <a href="index.html">Fancy</a></div></div></div>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="equals.html">equals</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">open fun <a href="equals.html">equals</a>(other: <a href="">Any</a>): <a href="">Boolean</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="hash-code.html">hashCode</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">open fun <a href="hash-code.html">hashCode</a>(): <a href="">Int</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="to-string.html">toString</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">open fun <a href="to-string.html">toString</a>(): <a href="">String</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+          <h2>Properties</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="">size</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final val <a href="">size</a>: <a href="">Int</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/to-string.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/to-string.html
new file mode 100644
index 00000000..4e1a0346
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/-fancy/to-string.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>toString</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="/Fancy/toString/#//">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a>/<a href="to-string.html">toString</a></div>
+          <div class="cover ">
+            <h1>toString</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">open fun <a href="to-string.html">toString</a>(): <a href="">String</a></div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/f.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/f.html
new file mode 100644
index 00000000..8044ccbf
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/f.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>f</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//f/#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="f.html">f</a></div>
+          <div class="cover ">
+            <h1>f</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..9b60126a
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/[main root]/index.html	
@@ -0,0 +1,69 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Types</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="-fancy/index.html">Fancy</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">annotation class <a href="-fancy/index.html">Fancy</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="f.html">f</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/index.html b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/package-list b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/package-list
index 8dcb9116..a5413b7c 100644
--- a/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/annotatedFunctionWithAnnotationParameters/out/html/root/package-list
@@ -1,8 +1,8 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://f/#//root/[jvm root]/f.html
-$dokka.location:/Fancy/equals/#kotlin.Any?//root/[jvm root]/-fancy/equals.html
-$dokka.location:/Fancy/hashCode/#//root/[jvm root]/-fancy/hash-code.html
-$dokka.location:/Fancy/toString/#//root/[jvm root]/-fancy/to-string.html
-[jvm root]
+$dokka.location://f/#//root/[main root]/f.html
+$dokka.location:/Fancy/equals/#kotlin.Any?//root/[main root]/-fancy/equals.html
+$dokka.location:/Fancy/hashCode/#//root/[main root]/-fancy/hash-code.html
+$dokka.location:/Fancy/toString/#//root/[main root]/-fancy/to-string.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/function/out/html/navigation.html b/plugins/base/src/test/resources/expect/function/out/html/navigation.html
index 3e532bec..f9058a8f 100644
--- a/plugins/base/src/test/resources/expect/function/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/function/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//fn/#//">
-      <div class="overview"><a href="root/[jvm root]/fn.html">fn</a></div>
+      <div class="overview"><a href="root/[main root]/fn.html">fn</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/function/out/html/root/[jvm root]/fn.html b/plugins/base/src/test/resources/expect/function/out/html/root/[jvm root]/fn.html
deleted file mode 100644
index abb882ae..00000000
--- a/plugins/base/src/test/resources/expect/function/out/html/root/[jvm root]/fn.html	
+++ /dev/null
@@ -1,34 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>fn</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//fn/#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="fn.html">fn</a></div>
-          <div class="cover ">
-            <h1>fn</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="fn.html">fn</a>()</div></div></div>
-          </div>
-          <h3>Description</h3>
-          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm">Function fn</div></div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/function/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/function/out/html/root/[jvm root]/index.html
deleted file mode 100644
index c7b72589..00000000
--- a/plugins/base/src/test/resources/expect/function/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="fn.html">fn</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="fn.html">fn</a>()</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/function/out/html/root/[main root]/fn.html b/plugins/base/src/test/resources/expect/function/out/html/root/[main root]/fn.html
new file mode 100644
index 00000000..775304da
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/function/out/html/root/[main root]/fn.html	
@@ -0,0 +1,34 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>fn</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//fn/#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="fn.html">fn</a></div>
+          <div class="cover ">
+            <h1>fn</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="fn.html">fn</a>()</div></div></div>
+          </div>
+          <h3>Description</h3>
+          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main">Function fn</div></div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/function/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/function/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..bc7f8f86
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/function/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="fn.html">fn</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="fn.html">fn</a>()</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/function/out/html/root/index.html b/plugins/base/src/test/resources/expect/function/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/function/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/function/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/function/out/html/root/package-list b/plugins/base/src/test/resources/expect/function/out/html/root/package-list
index 9430f445..d0e46007 100644
--- a/plugins/base/src/test/resources/expect/function/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/function/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://fn/#//root/[jvm root]/fn.html
-[jvm root]
+$dokka.location://fn/#//root/[main root]/fn.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/navigation.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/navigation.html
index df89ba77..dd3ea05b 100644
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/navigation.html
@@ -1,12 +1,12 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-    <div class="sideMenuPart" id="nav-submenu-0-0" pageId="[jvm root]/Fancy////">
-      <div class="overview"><a href="root/[jvm root]/-fancy/index.html">Fancy</a></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+    <div class="sideMenuPart" id="nav-submenu-0-0" pageId="[main root]/Fancy////">
+      <div class="overview"><a href="root/[main root]/-fancy/index.html">Fancy</a></div>
     </div>
     <div class="sideMenuPart" id="nav-submenu-0-1" pageId="//function/#kotlin.Function0[kotlin.Unit]//">
-      <div class="overview"><a href="root/[jvm root]/function.html">function</a></div>
+      <div class="overview"><a href="root/[main root]/function.html">function</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/-init-.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/-init-.html
deleted file mode 100644
index 5aa8aba5..00000000
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/-init-.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>&lt;init&gt;</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/Fancy/&lt;init&gt;/#//">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a>/<a href="-init-.html">&lt;init&gt;</a></div>
-          <div class="cover ">
-            <h1>&lt;init&gt;</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="-init-.html">&lt;init&gt;</a>()</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/equals.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/equals.html
deleted file mode 100644
index 52566473..00000000
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/equals.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>equals</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="/Fancy/equals/#kotlin.Any?//">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a>/<a href="equals.html">equals</a></div>
-          <div class="cover ">
-            <h1>equals</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">open fun <a href="equals.html">equals</a>(other: <a href="">Any</a>): <a href="">Boolean</a></div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/hash-code.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/hash-code.html
deleted file mode 100644
index 98338519..00000000
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/hash-code.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>hashCode</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="/Fancy/hashCode/#//">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a>/<a href="hash-code.html">hashCode</a></div>
-          <div class="cover ">
-            <h1>hashCode</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">open fun <a href="hash-code.html">hashCode</a>(): <a href="">Int</a></div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/index.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/index.html
deleted file mode 100644
index 14804ca4..00000000
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/index.html	
+++ /dev/null
@@ -1,83 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>Fancy</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/Fancy////">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a></div>
-          <div class="cover ">
-            <h1>Fancy</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">annotation class <a href="index.html">Fancy</a></div></div></div>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="equals.html">equals</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">open fun <a href="equals.html">equals</a>(other: <a href="">Any</a>): <a href="">Boolean</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="hash-code.html">hashCode</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">open fun <a href="hash-code.html">hashCode</a>(): <a href="">Int</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="to-string.html">toString</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">open fun <a href="to-string.html">toString</a>(): <a href="">String</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/to-string.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/to-string.html
deleted file mode 100644
index b64fcf93..00000000
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/-fancy/to-string.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>toString</title>
-    <link href="../../../styles/style.css" rel="Stylesheet">
-    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../../scripts/main.js"></script>
-        <div id="content" pageIds="/Fancy/toString/#//">
-          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[jvm root]</a>/<a href="index.html">Fancy</a>/<a href="to-string.html">toString</a></div>
-          <div class="cover ">
-            <h1>toString</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">open fun <a href="to-string.html">toString</a>(): <a href="">String</a></div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/function.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/function.html
deleted file mode 100644
index d4436f44..00000000
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/function.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>function</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//function/#kotlin.Function0[kotlin.Unit]//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="function.html">function</a></div>
-          <div class="cover ">
-            <h1>function</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="function.html">function</a>(notInlined: <div class="symbol monospace">() -&gt; <a href="">Unit</a></div>)</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/index.html
deleted file mode 100644
index e51fe2b2..00000000
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,69 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Types</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="-fancy/index.html">Fancy</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">annotation class <a href="-fancy/index.html">Fancy</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="function.html">function</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="function.html">function</a>(notInlined: <div class="symbol monospace">() -&gt; <a href="">Unit</a></div>)</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/-init-.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/-init-.html
new file mode 100644
index 00000000..80bf13d6
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/-init-.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>&lt;init&gt;</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/Fancy/&lt;init&gt;/#//">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a>/<a href="-init-.html">&lt;init&gt;</a></div>
+          <div class="cover ">
+            <h1>&lt;init&gt;</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="-init-.html">&lt;init&gt;</a>()</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/equals.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/equals.html
new file mode 100644
index 00000000..5de2c68d
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/equals.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>equals</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="/Fancy/equals/#kotlin.Any?//">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a>/<a href="equals.html">equals</a></div>
+          <div class="cover ">
+            <h1>equals</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">open fun <a href="equals.html">equals</a>(other: <a href="">Any</a>): <a href="">Boolean</a></div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/hash-code.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/hash-code.html
new file mode 100644
index 00000000..675c156f
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/hash-code.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>hashCode</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="/Fancy/hashCode/#//">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a>/<a href="hash-code.html">hashCode</a></div>
+          <div class="cover ">
+            <h1>hashCode</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">open fun <a href="hash-code.html">hashCode</a>(): <a href="">Int</a></div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/index.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/index.html
new file mode 100644
index 00000000..7445b029
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/index.html	
@@ -0,0 +1,83 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>Fancy</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/Fancy////">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a></div>
+          <div class="cover ">
+            <h1>Fancy</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">annotation class <a href="index.html">Fancy</a></div></div></div>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="equals.html">equals</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">open fun <a href="equals.html">equals</a>(other: <a href="">Any</a>): <a href="">Boolean</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="hash-code.html">hashCode</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">open fun <a href="hash-code.html">hashCode</a>(): <a href="">Int</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="to-string.html">toString</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">open fun <a href="to-string.html">toString</a>(): <a href="">String</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/to-string.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/to-string.html
new file mode 100644
index 00000000..4e1a0346
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/-fancy/to-string.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>toString</title>
+    <link href="../../../styles/style.css" rel="Stylesheet">
+    <link href="../../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../../scripts/main.js"></script>
+        <div id="content" pageIds="/Fancy/toString/#//">
+          <div class="breadcrumbs">//<a href="../../index.html">root</a>/<a href="../index.html">[main root]</a>/<a href="index.html">Fancy</a>/<a href="to-string.html">toString</a></div>
+          <div class="cover ">
+            <h1>toString</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">open fun <a href="to-string.html">toString</a>(): <a href="">String</a></div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/function.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/function.html
new file mode 100644
index 00000000..d7f9f550
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/function.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>function</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//function/#kotlin.Function0[kotlin.Unit]//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="function.html">function</a></div>
+          <div class="cover ">
+            <h1>function</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="function.html">function</a>(notInlined: <div class="symbol monospace">() -&gt; <a href="">Unit</a></div>)</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..b4ad01f5
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/[main root]/index.html	
@@ -0,0 +1,69 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Types</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="-fancy/index.html">Fancy</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">annotation class <a href="-fancy/index.html">Fancy</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="function.html">function</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="function.html">function</a>(notInlined: <div class="symbol monospace">() -&gt; <a href="">Unit</a></div>)</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/index.html b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/package-list b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/package-list
index 141e96fd..fb79fbe8 100644
--- a/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/functionWithAnnotatedParam/out/html/root/package-list
@@ -1,8 +1,8 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://function/#kotlin.Function0[kotlin.Unit]//root/[jvm root]/function.html
-$dokka.location:/Fancy/equals/#kotlin.Any?//root/[jvm root]/-fancy/equals.html
-$dokka.location:/Fancy/hashCode/#//root/[jvm root]/-fancy/hash-code.html
-$dokka.location:/Fancy/toString/#//root/[jvm root]/-fancy/to-string.html
-[jvm root]
+$dokka.location://function/#kotlin.Function0[kotlin.Unit]//root/[main root]/function.html
+$dokka.location:/Fancy/equals/#kotlin.Any?//root/[main root]/-fancy/equals.html
+$dokka.location:/Fancy/hashCode/#//root/[main root]/-fancy/hash-code.html
+$dokka.location:/Fancy/toString/#//root/[main root]/-fancy/to-string.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/navigation.html b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/navigation.html
index 6d159123..7edbae7d 100644
--- a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//f/#kotlin.String//">
-      <div class="overview"><a href="root/[jvm root]/f.html">f</a></div>
+      <div class="overview"><a href="root/[main root]/f.html">f</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[jvm root]/f.html b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[jvm root]/f.html
deleted file mode 100644
index c395f3b6..00000000
--- a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[jvm root]/f.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>f</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//f/#kotlin.String//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="f.html">f</a></div>
-          <div class="cover ">
-            <h1>f</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="f.html">f</a>(x: <a href="">String</a>)</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 9e048fbe..00000000
--- a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="f.html">f</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>(x: <a href="">String</a>)</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[main root]/f.html b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[main root]/f.html
new file mode 100644
index 00000000..dedf121b
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[main root]/f.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>f</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//f/#kotlin.String//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="f.html">f</a></div>
+          <div class="cover ">
+            <h1>f</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="f.html">f</a>(x: <a href="">String</a>)</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..47b5a8ae
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="f.html">f</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>(x: <a href="">String</a>)</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/index.html b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/package-list b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/package-list
index 2887ed99..e733b252 100644
--- a/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/functionWithDefaultParameter/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://f/#kotlin.String//root/[jvm root]/f.html
-[jvm root]
+$dokka.location://f/#kotlin.String//root/[main root]/f.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/navigation.html b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/navigation.html
index b3a068a3..e75d2599 100644
--- a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//function/#kotlin.Function0[kotlin.Unit]//">
-      <div class="overview"><a href="root/[jvm root]/function.html">function</a></div>
+      <div class="overview"><a href="root/[main root]/function.html">function</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[jvm root]/function.html b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[jvm root]/function.html
deleted file mode 100644
index d4436f44..00000000
--- a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[jvm root]/function.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>function</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//function/#kotlin.Function0[kotlin.Unit]//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="function.html">function</a></div>
-          <div class="cover ">
-            <h1>function</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="function.html">function</a>(notInlined: <div class="symbol monospace">() -&gt; <a href="">Unit</a></div>)</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 4825e352..00000000
--- a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="function.html">function</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="function.html">function</a>(notInlined: <div class="symbol monospace">() -&gt; <a href="">Unit</a></div>)</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[main root]/function.html b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[main root]/function.html
new file mode 100644
index 00000000..d7f9f550
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[main root]/function.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>function</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//function/#kotlin.Function0[kotlin.Unit]//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="function.html">function</a></div>
+          <div class="cover ">
+            <h1>function</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="function.html">function</a>(notInlined: <div class="symbol monospace">() -&gt; <a href="">Unit</a></div>)</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..8201541c
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="function.html">function</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="function.html">function</a>(notInlined: <div class="symbol monospace">() -&gt; <a href="">Unit</a></div>)</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/index.html b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/package-list b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/package-list
index 4200e2d8..73470d00 100644
--- a/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/functionWithNoinlineParam/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://function/#kotlin.Function0[kotlin.Unit]//root/[jvm root]/function.html
-[jvm root]
+$dokka.location://function/#kotlin.Function0[kotlin.Unit]//root/[main root]/function.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/navigation.html b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/navigation.html
index 35fe78dc..29daddec 100644
--- a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//f/#//">
-      <div class="overview"><a href="root/[jvm root]/f.html">f</a></div>
+      <div class="overview"><a href="root/[main root]/f.html">f</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[jvm root]/f.html b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[jvm root]/f.html
deleted file mode 100644
index 6ca7daa7..00000000
--- a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[jvm root]/f.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>f</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//f/#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="f.html">f</a></div>
-          <div class="cover ">
-            <h1>f</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[jvm root]/index.html
deleted file mode 100644
index d1b41977..00000000
--- a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="f.html">f</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[main root]/f.html b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[main root]/f.html
new file mode 100644
index 00000000..8044ccbf
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[main root]/f.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>f</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//f/#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="f.html">f</a></div>
+          <div class="cover ">
+            <h1>f</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..9668ba81
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="f.html">f</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/index.html b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/package-list b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/package-list
index 8f1c5fd9..aed2a34c 100644
--- a/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/functionWithNotDocumentedAnnotation/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://f/#//root/[jvm root]/f.html
-[jvm root]
+$dokka.location://f/#//root/[main root]/f.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/functionWithParams/out/html/navigation.html b/plugins/base/src/test/resources/expect/functionWithParams/out/html/navigation.html
index 9e098fd0..2b6b4beb 100644
--- a/plugins/base/src/test/resources/expect/functionWithParams/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/functionWithParams/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//function/#kotlin.Int//">
-      <div class="overview"><a href="root/[jvm root]/function.html">function</a></div>
+      <div class="overview"><a href="root/[main root]/function.html">function</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[jvm root]/function.html b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[jvm root]/function.html
deleted file mode 100644
index 0fb966a6..00000000
--- a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[jvm root]/function.html	
+++ /dev/null
@@ -1,34 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>function</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//function/#kotlin.Int//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="function.html">function</a></div>
-          <div class="cover ">
-            <h1>function</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="function.html">function</a>(x: <a href="">Int</a>)</div></div></div>
-          </div>
-          <h3>Description</h3>
-          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm">MultilineFunction Documentation</div></div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 31271e45..00000000
--- a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="function.html">function</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="function.html">function</a>(x: <a href="">Int</a>)</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[main root]/function.html b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[main root]/function.html
new file mode 100644
index 00000000..98af2216
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[main root]/function.html	
@@ -0,0 +1,34 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>function</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//function/#kotlin.Int//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="function.html">function</a></div>
+          <div class="cover ">
+            <h1>function</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="function.html">function</a>(x: <a href="">Int</a>)</div></div></div>
+          </div>
+          <h3>Description</h3>
+          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main">MultilineFunction Documentation</div></div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..e2a0259d
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="function.html">function</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="function.html">function</a>(x: <a href="">Int</a>)</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/index.html b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/package-list b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/package-list
index 6394d253..445b2e70 100644
--- a/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/functionWithParams/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://function/#kotlin.Int//root/[jvm root]/function.html
-[jvm root]
+$dokka.location://function/#kotlin.Int//root/[main root]/function.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/navigation.html b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/navigation.html
index d5d3a9f4..daefbd81 100644
--- a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//fn/kotlin.String#//">
-      <div class="overview"><a href="root/[jvm root]/fn.html">fn</a></div>
+      <div class="overview"><a href="root/[main root]/fn.html">fn</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[jvm root]/fn.html b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[jvm root]/fn.html
deleted file mode 100644
index a922d72f..00000000
--- a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[jvm root]/fn.html	
+++ /dev/null
@@ -1,40 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>fn</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//fn/kotlin.String#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="fn.html">fn</a></div>
-          <div class="cover ">
-            <h1>fn</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="">String</a>.<a href="fn.html">fn</a>()</div></div></div>
-          </div>
-          <h3>Description</h3>
-          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm">Function with receiver</div></div>
-          <div class="cover ">
-            <h1>fn</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="">String</a>.<a href="fn.html">fn</a>(x: <a href="">Int</a>)</div></div></div>
-          </div>
-          <h3>Description</h3>
-          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm">Function with receiver</div></div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[jvm root]/index.html
deleted file mode 100644
index a646eb63..00000000
--- a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,66 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="fn.html">fn</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="">String</a>.<a href="fn.html">fn</a>()</div></div></div></div>
-                </div>
-              </div>
-            </div>
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="fn.html">fn</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="">String</a>.<a href="fn.html">fn</a>(x: <a href="">Int</a>)</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[main root]/fn.html b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[main root]/fn.html
new file mode 100644
index 00000000..03feac23
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[main root]/fn.html	
@@ -0,0 +1,40 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>fn</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//fn/kotlin.String#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="fn.html">fn</a></div>
+          <div class="cover ">
+            <h1>fn</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="">String</a>.<a href="fn.html">fn</a>()</div></div></div>
+          </div>
+          <h3>Description</h3>
+          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main">Function with receiver</div></div>
+          <div class="cover ">
+            <h1>fn</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="">String</a>.<a href="fn.html">fn</a>(x: <a href="">Int</a>)</div></div></div>
+          </div>
+          <h3>Description</h3>
+          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main">Function with receiver</div></div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..164f42e9
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/[main root]/index.html	
@@ -0,0 +1,66 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="fn.html">fn</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="">String</a>.<a href="fn.html">fn</a>()</div></div></div></div>
+                </div>
+              </div>
+            </div>
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="fn.html">fn</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="">String</a>.<a href="fn.html">fn</a>(x: <a href="">Int</a>)</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/index.html b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/package-list b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/package-list
index faeb244b..42c919d9 100644
--- a/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/functionWithReceiver/out/html/root/package-list
@@ -1,6 +1,6 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://fn/kotlin.String#//root/[jvm root]/fn.html
-$dokka.location://fn/kotlin.String#kotlin.Int//root/[jvm root]/fn.html
-[jvm root]
+$dokka.location://fn/kotlin.String#//root/[main root]/fn.html
+$dokka.location://fn/kotlin.String#kotlin.Int//root/[main root]/fn.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/genericFunction/out/html/navigation.html b/plugins/base/src/test/resources/expect/genericFunction/out/html/navigation.html
index 006a9e3e..cddadabd 100644
--- a/plugins/base/src/test/resources/expect/genericFunction/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/genericFunction/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//generic/#//">
-      <div class="overview"><a href="root/[jvm root]/generic.html">generic</a></div>
+      <div class="overview"><a href="root/[main root]/generic.html">generic</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[jvm root]/generic.html b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[jvm root]/generic.html
deleted file mode 100644
index 91519d2b..00000000
--- a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[jvm root]/generic.html	
+++ /dev/null
@@ -1,34 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>generic</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//generic/#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="generic.html">generic</a></div>
-          <div class="cover ">
-            <h1>generic</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">private final fun &lt;<a href="generic.html">T</a> : <a href="">Any</a>&gt; <a href="generic.html">generic</a>()</div></div></div>
-          </div>
-          <h3>Description</h3>
-          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm">generic function</div></div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 89261f63..00000000
--- a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="generic.html">generic</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">private final fun &lt;<a href="generic.html">T</a> : <a href="">Any</a>&gt; <a href="generic.html">generic</a>()</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[main root]/generic.html b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[main root]/generic.html
new file mode 100644
index 00000000..de568b54
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[main root]/generic.html	
@@ -0,0 +1,34 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>generic</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//generic/#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="generic.html">generic</a></div>
+          <div class="cover ">
+            <h1>generic</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">private final fun &lt;<a href="generic.html">T</a> : <a href="">Any</a>&gt; <a href="generic.html">generic</a>()</div></div></div>
+          </div>
+          <h3>Description</h3>
+          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main">generic function</div></div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..65c8f4b6
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="generic.html">generic</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">private final fun &lt;<a href="generic.html">T</a> : <a href="">Any</a>&gt; <a href="generic.html">generic</a>()</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/index.html b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/package-list b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/package-list
index 468c6cb4..328a6811 100644
--- a/plugins/base/src/test/resources/expect/genericFunction/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/genericFunction/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://generic/#//root/[jvm root]/generic.html
-[jvm root]
+$dokka.location://generic/#//root/[main root]/generic.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/navigation.html b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/navigation.html
index 006a9e3e..cddadabd 100644
--- a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//generic/#//">
-      <div class="overview"><a href="root/[jvm root]/generic.html">generic</a></div>
+      <div class="overview"><a href="root/[main root]/generic.html">generic</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[jvm root]/generic.html b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[jvm root]/generic.html
deleted file mode 100644
index 3e44781b..00000000
--- a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[jvm root]/generic.html	
+++ /dev/null
@@ -1,34 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>generic</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//generic/#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="generic.html">generic</a></div>
-          <div class="cover ">
-            <h1>generic</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun &lt;<a href="generic.html">T</a> : R, <a href="generic.html">R</a> : <a href="">Any</a>&gt; <a href="generic.html">generic</a>()</div></div></div>
-          </div>
-          <h3>Description</h3>
-          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm">generic function</div></div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 4d02021a..00000000
--- a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="generic.html">generic</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun &lt;<a href="generic.html">T</a> : R, <a href="generic.html">R</a> : <a href="">Any</a>&gt; <a href="generic.html">generic</a>()</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[main root]/generic.html b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[main root]/generic.html
new file mode 100644
index 00000000..af73a7ae
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[main root]/generic.html	
@@ -0,0 +1,34 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>generic</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//generic/#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="generic.html">generic</a></div>
+          <div class="cover ">
+            <h1>generic</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun &lt;<a href="generic.html">T</a> : R, <a href="generic.html">R</a> : <a href="">Any</a>&gt; <a href="generic.html">generic</a>()</div></div></div>
+          </div>
+          <h3>Description</h3>
+          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main">generic function</div></div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..6d091562
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="generic.html">generic</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun &lt;<a href="generic.html">T</a> : R, <a href="generic.html">R</a> : <a href="">Any</a>&gt; <a href="generic.html">generic</a>()</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/index.html b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/package-list b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/package-list
index 468c6cb4..328a6811 100644
--- a/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/genericFunctionWithConstraints/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://generic/#//root/[jvm root]/generic.html
-[jvm root]
+$dokka.location://generic/#//root/[main root]/generic.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/inlineFunction/out/html/navigation.html b/plugins/base/src/test/resources/expect/inlineFunction/out/html/navigation.html
index f949d074..b3656a55 100644
--- a/plugins/base/src/test/resources/expect/inlineFunction/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/inlineFunction/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//f/#kotlin.Function0[kotlin.String]//">
-      <div class="overview"><a href="root/[jvm root]/f.html">f</a></div>
+      <div class="overview"><a href="root/[main root]/f.html">f</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[jvm root]/f.html b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[jvm root]/f.html
deleted file mode 100644
index 3766ad15..00000000
--- a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[jvm root]/f.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>f</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//f/#kotlin.Function0[kotlin.String]//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="f.html">f</a></div>
-          <div class="cover ">
-            <h1>f</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 26d40926..00000000
--- a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="f.html">f</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[main root]/f.html b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[main root]/f.html
new file mode 100644
index 00000000..f6fdb40a
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[main root]/f.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>f</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//f/#kotlin.Function0[kotlin.String]//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="f.html">f</a></div>
+          <div class="cover ">
+            <h1>f</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..79216743
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="f.html">f</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/index.html b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/package-list b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/package-list
index ce137c16..26e2f605 100644
--- a/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/inlineFunction/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://f/#kotlin.Function0[kotlin.String]//root/[jvm root]/f.html
-[jvm root]
+$dokka.location://f/#kotlin.Function0[kotlin.String]//root/[main root]/f.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/navigation.html b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/navigation.html
index f949d074..b3656a55 100644
--- a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//f/#kotlin.Function0[kotlin.String]//">
-      <div class="overview"><a href="root/[jvm root]/f.html">f</a></div>
+      <div class="overview"><a href="root/[main root]/f.html">f</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[jvm root]/f.html b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[jvm root]/f.html
deleted file mode 100644
index 3766ad15..00000000
--- a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[jvm root]/f.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>f</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//f/#kotlin.Function0[kotlin.String]//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="f.html">f</a></div>
-          <div class="cover ">
-            <h1>f</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 26d40926..00000000
--- a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="f.html">f</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[main root]/f.html b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[main root]/f.html
new file mode 100644
index 00000000..f6fdb40a
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[main root]/f.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>f</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//f/#kotlin.Function0[kotlin.String]//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="f.html">f</a></div>
+          <div class="cover ">
+            <h1>f</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..79216743
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="f.html">f</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/index.html b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/package-list b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/package-list
index ce137c16..26e2f605 100644
--- a/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/inlineSuspendFunction/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://f/#kotlin.Function0[kotlin.String]//root/[jvm root]/f.html
-[jvm root]
+$dokka.location://f/#kotlin.Function0[kotlin.String]//root/[main root]/f.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/signatureTest/out/html/root/index.html b/plugins/base/src/test/resources/expect/signatureTest/out/html/root/index.html
index fd166ca9..03fe3b32 100644
--- a/plugins/base/src/test/resources/expect/signatureTest/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/signatureTest/out/html/root/index.html
@@ -29,7 +29,7 @@
               <div class="main-subrow">
                 <div class="title"><a href="signatureTest/index.html">signatureTest</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/index.html b/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/index.html
index 8d27b36e..4147b88e 100644
--- a/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/index.html
+++ b/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/index.html
@@ -32,12 +32,12 @@
                   <div class="brief "> </div>
                 </div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
               <div class="signature-subrow">
                 <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="test.html">test</a>(i: <div class="symbol monospace">(<a href="">Int</a>) -&gt; <a href="">Int</a></div>)</div></div></div></div>
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="test.html">test</a>(i: <div class="symbol monospace">(<a href="">Int</a>) -&gt; <a href="">Int</a></div>)</div></div></div></div>
                 </div>
               </div>
             </div>
@@ -48,12 +48,12 @@
                   <div class="brief "> </div>
                 </div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
               <div class="signature-subrow">
                 <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="test2.html">test2</a>(i: <div class="symbol monospace"><a href="">Int</a>.(<a href="">Int</a>) -&gt; <a href="">Int</a></div>)</div></div></div></div>
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="test2.html">test2</a>(i: <div class="symbol monospace"><a href="">Int</a>.(<a href="">Int</a>) -&gt; <a href="">Int</a></div>)</div></div></div></div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/test.html b/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/test.html
index 0252ebc5..333ee75a 100644
--- a/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/test.html
+++ b/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/test.html
@@ -22,7 +22,7 @@
           <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">signatureTest</a>/<a href="test.html">test</a></div>
           <div class="cover ">
             <h1>test</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="test.html">test</a>(i: <div class="symbol monospace">(<a href="">Int</a>) -&gt; <a href="">Int</a></div>)</div></div></div>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="test.html">test</a>(i: <div class="symbol monospace">(<a href="">Int</a>) -&gt; <a href="">Int</a></div>)</div></div></div>
           </div>
         </div>
       </div>
diff --git a/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/test2.html b/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/test2.html
index ab388675..ebc34123 100644
--- a/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/test2.html
+++ b/plugins/base/src/test/resources/expect/signatureTest/out/html/root/signatureTest/test2.html
@@ -22,7 +22,7 @@
           <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">signatureTest</a>/<a href="test2.html">test2</a></div>
           <div class="cover ">
             <h1>test2</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="test2.html">test2</a>(i: <div class="symbol monospace"><a href="">Int</a>.(<a href="">Int</a>) -&gt; <a href="">Int</a></div>)</div></div></div>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="test2.html">test2</a>(i: <div class="symbol monospace"><a href="">Int</a>.(<a href="">Int</a>) -&gt; <a href="">Int</a></div>)</div></div></div>
           </div>
         </div>
       </div>
diff --git a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/navigation.html b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/navigation.html
index ff1a753c..8e375351 100644
--- a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//availableSince1.1/#//">
-      <div class="overview"><a href="root/[jvm root]/available-since1.1.html">availableSince1.1</a></div>
+      <div class="overview"><a href="root/[main root]/available-since1.1.html">availableSince1.1</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[jvm root]/available-since1.1.html b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[jvm root]/available-since1.1.html
deleted file mode 100644
index cdf2898c..00000000
--- a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[jvm root]/available-since1.1.html	
+++ /dev/null
@@ -1,34 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>availableSince1.1</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//availableSince1.1/#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="available-since1.1.html">availableSince1.1</a></div>
-          <div class="cover ">
-            <h1>availableSince1.1</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="available-since1.1.html">availableSince1.1</a>(): <a href="">String</a></div></div></div>
-          </div>
-          <h3>Description</h3>
-          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm">Quite useful <a href="">String</a></div></div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[jvm root]/index.html
deleted file mode 100644
index ee56ace9..00000000
--- a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="available-since1.1.html">availableSince1.1</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="available-since1.1.html">availableSince1.1</a>(): <a href="">String</a></div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[main root]/available-since1.1.html b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[main root]/available-since1.1.html
new file mode 100644
index 00000000..d02eb734
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[main root]/available-since1.1.html	
@@ -0,0 +1,34 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>availableSince1.1</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//availableSince1.1/#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="available-since1.1.html">availableSince1.1</a></div>
+          <div class="cover ">
+            <h1>availableSince1.1</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="available-since1.1.html">availableSince1.1</a>(): <a href="">String</a></div></div></div>
+          </div>
+          <h3>Description</h3>
+          <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main">Quite useful <a href="">String</a></div></div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..cde151a7
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="available-since1.1.html">availableSince1.1</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="available-since1.1.html">availableSince1.1</a>(): <a href="">String</a></div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/index.html b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/package-list b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/package-list
index adc667ec..c90f53ec 100644
--- a/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/sinceKotlin/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://availableSince1.1/#//root/[jvm root]/available-since1.1.html
-[jvm root]
+$dokka.location://availableSince1.1/#//root/[main root]/available-since1.1.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/suspendFunction/out/html/navigation.html b/plugins/base/src/test/resources/expect/suspendFunction/out/html/navigation.html
index 35fe78dc..29daddec 100644
--- a/plugins/base/src/test/resources/expect/suspendFunction/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/suspendFunction/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//f/#//">
-      <div class="overview"><a href="root/[jvm root]/f.html">f</a></div>
+      <div class="overview"><a href="root/[main root]/f.html">f</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[jvm root]/f.html b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[jvm root]/f.html
deleted file mode 100644
index 6ca7daa7..00000000
--- a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[jvm root]/f.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>f</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//f/#//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="f.html">f</a></div>
-          <div class="cover ">
-            <h1>f</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[jvm root]/index.html
deleted file mode 100644
index d1b41977..00000000
--- a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="f.html">f</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[main root]/f.html b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[main root]/f.html
new file mode 100644
index 00000000..8044ccbf
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[main root]/f.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>f</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//f/#//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="f.html">f</a></div>
+          <div class="cover ">
+            <h1>f</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..9668ba81
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="f.html">f</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>()</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/index.html b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/package-list b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/package-list
index 8f1c5fd9..aed2a34c 100644
--- a/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/suspendFunction/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://f/#//root/[jvm root]/f.html
-[jvm root]
+$dokka.location://f/#//root/[main root]/f.html
+[main root]
 
diff --git a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/navigation.html b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/navigation.html
index f949d074..b3656a55 100644
--- a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/navigation.html
+++ b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/navigation.html
@@ -1,9 +1,9 @@
 <div class="sideMenuPart" id="nav-submenu" pageId="/////">
   <div class="overview"><a href="root/index.html">root</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
-  <div class="sideMenuPart" id="nav-submenu-0" pageId="[jvm root]/////">
-    <div class="overview"><a href="root/[jvm root]/index.html">[jvm root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
+  <div class="sideMenuPart" id="nav-submenu-0" pageId="[main root]/////">
+    <div class="overview"><a href="root/[main root]/index.html">[main root]</a><span class="navButton" onclick="document.getElementById(&quot;nav-submenu-0&quot;).classList.toggle(&quot;hidden&quot;);"><span class="navButtonContent"></span></span></div>
     <div class="sideMenuPart" id="nav-submenu-0-0" pageId="//f/#kotlin.Function0[kotlin.String]//">
-      <div class="overview"><a href="root/[jvm root]/f.html">f</a></div>
+      <div class="overview"><a href="root/[main root]/f.html">f</a></div>
     </div>
   </div>
 </div>
diff --git a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[jvm root]/f.html b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[jvm root]/f.html
deleted file mode 100644
index 3766ad15..00000000
--- a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[jvm root]/f.html	
+++ /dev/null
@@ -1,32 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>f</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="//f/#kotlin.Function0[kotlin.String]//">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a>/<a href="f.html">f</a></div>
-          <div class="cover ">
-            <h1>f</h1>
-            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[jvm root]/index.html b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[jvm root]/index.html
deleted file mode 100644
index 26d40926..00000000
--- a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[jvm root]/index.html	
+++ /dev/null
@@ -1,50 +0,0 @@
-<html>
-  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
-    <title>[jvm root]</title>
-    <link href="../../styles/style.css" rel="Stylesheet">
-    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
-    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
-    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
-    <script>var pathToRoot = "../../";</script>
-  </head>
-  <body>
-    <div id="container">
-      <div id="leftColumn">
-        <div id="logo"></div>
-        <div id="sideMenu"></div>
-      </div>
-      <div id="main">
-        <div id="searchBar"></div>
-        <script type="text/javascript" src="../../scripts/pages.js"></script>
-        <script type="text/javascript" src="../../scripts/main.js"></script>
-        <div id="content" pageIds="[jvm root]/////">
-          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[jvm root]</a></div>
-          <div class="cover ">
-            <h1>Package [jvm root]</h1>
-          </div>
-          <h2>Functions</h2>
-          <div class="table">
-            <div class="table-row">
-              <div class="main-subrow">
-                <div class="title"><a href="f.html">f</a></div>
-                <div class="brief">
-                  <div class="brief "> </div>
-                </div>
-                <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
-                </div>
-              </div>
-              <div class="signature-subrow">
-                <div class="signatures">
-                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="jvm"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div></div>
-                </div>
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  </body>
-</html>
-
diff --git a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[main root]/f.html b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[main root]/f.html
new file mode 100644
index 00000000..f6fdb40a
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[main root]/f.html	
@@ -0,0 +1,32 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>f</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="//f/#kotlin.Function0[kotlin.String]//">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a>/<a href="f.html">f</a></div>
+          <div class="cover ">
+            <h1>f</h1>
+            <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[main root]/index.html b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[main root]/index.html
new file mode 100644
index 00000000..79216743
--- /dev/null
+++ b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/[main root]/index.html	
@@ -0,0 +1,50 @@
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" charset="UTF-8">
+    <title>[main root]</title>
+    <link href="../../styles/style.css" rel="Stylesheet">
+    <link href="../../styles/jetbrains-mono.css" rel="Stylesheet">
+    <script type="text/javascript" src="../../scripts/navigationLoader.js" async="async"></script>
+    <script type="text/javascript" src="../../scripts/platformContentHandler.js" async="async"></script>
+    <script>var pathToRoot = "../../";</script>
+  </head>
+  <body>
+    <div id="container">
+      <div id="leftColumn">
+        <div id="logo"></div>
+        <div id="sideMenu"></div>
+      </div>
+      <div id="main">
+        <div id="searchBar"></div>
+        <script type="text/javascript" src="../../scripts/pages.js"></script>
+        <script type="text/javascript" src="../../scripts/main.js"></script>
+        <div id="content" pageIds="[main root]/////">
+          <div class="breadcrumbs">//<a href="../index.html">root</a>/<a href="index.html">[main root]</a></div>
+          <div class="cover ">
+            <h1>Package [main root]</h1>
+          </div>
+          <h2>Functions</h2>
+          <div class="table">
+            <div class="table-row">
+              <div class="main-subrow">
+                <div class="title"><a href="f.html">f</a></div>
+                <div class="brief">
+                  <div class="brief "> </div>
+                </div>
+                <div class="platform-tags">
+                  <div class="platform-tag">main</div>
+                </div>
+              </div>
+              <div class="signature-subrow">
+                <div class="signatures">
+                  <div class="platform-hinted" data-platform-hinted="data-platform-hinted"><div class="content" data-active="" data-togglable="main"><div class="symbol "><div class="symbol monospace">final fun <a href="f.html">f</a>(a: <div class="symbol monospace">() -&gt; <a href="">String</a></div>)</div></div></div></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>
+
diff --git a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/index.html b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/index.html
index 2c55944d..2b62b11c 100644
--- a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/index.html
+++ b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/index.html
@@ -27,9 +27,9 @@
           <div class="table">
             <div class="table-row">
               <div class="main-subrow">
-                <div class="title"><a href="[jvm root]/index.html">[jvm root]</a></div>
+                <div class="title"><a href="[main root]/index.html">[main root]</a></div>
                 <div class="platform-tags">
-                  <div class="platform-tag">jvm</div>
+                  <div class="platform-tag">main</div>
                 </div>
               </div>
             </div>
diff --git a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/package-list b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/package-list
index ce137c16..26e2f605 100644
--- a/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/package-list
+++ b/plugins/base/src/test/resources/expect/suspendInlineFunction/out/html/root/package-list
@@ -1,5 +1,5 @@
 $dokka.format:html
 $dokka.linkExtension:html
-$dokka.location://f/#kotlin.Function0[kotlin.String]//root/[jvm root]/f.html
-[jvm root]
+$dokka.location://f/#kotlin.Function0[kotlin.String]//root/[main root]/f.html
+[main root]
 
diff --git a/plugins/gfm/src/main/kotlin/GfmPlugin.kt b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
index c65f3673..b7e9f6ab 100644
--- a/plugins/gfm/src/main/kotlin/GfmPlugin.kt
+++ b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
@@ -7,6 +7,7 @@ import org.jetbrains.dokka.base.renderers.PackageListCreator
 import org.jetbrains.dokka.base.renderers.RootCreator
 import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProvider
 import org.jetbrains.dokka.base.resolvers.local.LocationProviderFactory
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
@@ -62,7 +63,7 @@ open class CommonmarkRenderer(
         append("]($address)")
     }
 
-    override fun StringBuilder.buildList(node: ContentList, pageContext: ContentPage, platformRestriction: PlatformData?) {
+    override fun StringBuilder.buildList(node: ContentList, pageContext: ContentPage, platformRestriction: SourceSetData?) {
         buildParagraph()
         buildListLevel(node, pageContext)
         buildParagraph()
@@ -107,15 +108,15 @@ open class CommonmarkRenderer(
     }
 
     override fun StringBuilder.buildPlatformDependent(content: PlatformHintedContent, pageContext: ContentPage) {
-        val distinct = content.platforms.map {
+        val distinct = content.sourceSets.map {
             it to StringBuilder().apply {buildContentNode(content.inner, pageContext, it) }.toString()
-        }.groupBy(Pair<PlatformData, String>::second, Pair<PlatformData, String>::first)
+        }.groupBy(Pair<SourceSetData, String>::second, Pair<SourceSetData, String>::first)
 
         if (distinct.size == 1)
             append(distinct.keys.single())
         else
             distinct.forEach { text, platforms ->
-                append(platforms.joinToString(prefix = " [", postfix = "] $text") { it.name })
+                append(platforms.joinToString(prefix = " [", postfix = "] $text") { "${it.moduleName}/${it.sourceSetName}"  })
             }
     }
 
@@ -123,7 +124,7 @@ open class CommonmarkRenderer(
         append("Resource")
     }
 
-    override fun StringBuilder.buildTable(node: ContentTable, pageContext: ContentPage, platformRestriction: PlatformData?) {
+    override fun StringBuilder.buildTable(node: ContentTable, pageContext: ContentPage, platformRestriction: SourceSetData?) {
 
         buildParagraph()
         val size = node.children.firstOrNull()?.children?.size ?: 0
diff --git a/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt b/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt
index 0befe077..5a77016d 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/converters/KotlinToJavaConverter.kt
@@ -17,7 +17,7 @@ private fun <T : WithExpectActual> List<T>.groupedByLocation() =
     map { it.sources to it }
         .groupBy({ (location, _) ->
             location.let {
-                it.map.entries.first().value.path.split("/").last().split(".").first() + "Kt"
+                it.entries.first().value.path.split("/").last().split(".").first() + "Kt"
             } // TODO: first() does not look reasonable
         }) { it.second }
 
@@ -37,18 +37,17 @@ internal fun DPackage.asJava(): DPackage {
                                 nodes.filterIsInstance<DFunction>()
                                     .map { it.asJava(syntheticClassName) }), // TODO: methods are static and receiver is a param
                 classlikes = emptyList(),
-                sources = PlatformDependent.empty(),
-                visibility = PlatformDependent(
-                    platformData.map {
-                        it to JavaVisibility.Public
-                    }.toMap()
-                ),
+                sources = emptyMap(),
+                expectPresentInSet = null,
+                visibility = sourceSets.map {
+                    it to JavaVisibility.Public
+                }.toMap(),
                 companion = null,
                 generics = emptyList(),
-                supertypes = PlatformDependent.empty(),
-                documentation = PlatformDependent.empty(),
-                modifier = PlatformDependent(map = platformData.map{ it to JavaModifier.Final}.toMap()),
-                platformData = platformData,
+                supertypes = emptyMap(),
+                documentation = emptyMap(),
+                modifier = sourceSets.map{ it to JavaModifier.Final}.toMap(),
+                sourceSets = sourceSets,
                 extra = PropertyContainer.empty()
             )
         }
@@ -68,13 +67,11 @@ internal fun DProperty.asJava(isTopLevel: Boolean = false, relocateToClass: Stri
             dri.withClass(relocateToClass)
         },
         modifier = if (setter == null) {
-            PlatformDependent(map = platformData.map{it to JavaModifier.Final}.toMap())
+            sourceSets.map{it to JavaModifier.Final}.toMap()
         } else {
-            PlatformDependent(map = platformData.map{it to JavaModifier.Empty}.toMap())
+            sourceSets.map{it to JavaModifier.Empty}.toMap()
         },
-        visibility = visibility.copy(
-            map = visibility.mapValues { JavaVisibility.Private }
-        ),
+        visibility = visibility.mapValues { JavaVisibility.Private },
         type = type.asJava(), // TODO: check
         setter = null,
         getter = null, // Removing getters and setters as they will be available as functions
@@ -91,13 +88,11 @@ internal fun DProperty.javaAccessors(isTopLevel: Boolean = false, relocateToClas
             },
             name = "get" + name.capitalize(),
             modifier = if (setter == null) {
-                PlatformDependent(map = platformData.map{it to JavaModifier.Final}.toMap())
+                sourceSets.map{it to JavaModifier.Final}.toMap()
             } else {
-                PlatformDependent(map = platformData.map{it to JavaModifier.Empty}.toMap())
+                sourceSets.map{it to JavaModifier.Empty}.toMap()
             },
-            visibility = visibility.copy(
-                map = visibility.mapValues { JavaVisibility.Public }
-            ),
+            visibility = visibility.mapValues { JavaVisibility.Public },
             type = type.asJava(), // TODO: check
             extra = if (isTopLevel) getter!!.extra.plus(getter!!.extra.mergeAdditionalModifiers(setOf(ExtraModifiers.STATIC))) else getter!!.extra
         ),
@@ -109,13 +104,11 @@ internal fun DProperty.javaAccessors(isTopLevel: Boolean = false, relocateToClas
             },
             name = "set" + name.capitalize(),
             modifier = if (setter == null) {
-                PlatformDependent(map = platformData.map{it to JavaModifier.Final}.toMap())
+                sourceSets.map{it to JavaModifier.Final}.toMap()
             } else {
-                PlatformDependent(map = platformData.map{it to JavaModifier.Empty}.toMap())
+                sourceSets.map{it to JavaModifier.Empty}.toMap()
             },
-            visibility = visibility.copy(
-                map = visibility.mapValues { JavaVisibility.Public }
-            ),
+            visibility = visibility.mapValues { JavaVisibility.Public },
             type = type.asJava(), // TODO: check
             extra = if (isTopLevel) setter!!.extra.plus(setter!!.extra.mergeAdditionalModifiers(setOf(ExtraModifiers.STATIC))) else setter!!.extra
         )
@@ -132,8 +125,8 @@ internal fun DFunction.asJava(containingClassName: String): DFunction {
         name = newName,
         type = type.asJava(),
         modifier = if(modifier.all{(_,v)-> v is KotlinModifier.Final} && isConstructor)
-            PlatformDependent(map = platformData.map{it to JavaModifier.Empty}.toMap())
-        else PlatformDependent(map = platformData.map{it to modifier.allValues.first()}.toMap()),
+            sourceSets.map{it to JavaModifier.Empty}.toMap()
+        else sourceSets.map{it to modifier.values.first()}.toMap(),
         parameters = listOfNotNull(receiver?.asJava()) + parameters.map { it.asJava() },
         receiver = null
     ) // TODO static if toplevel
@@ -156,11 +149,9 @@ internal fun DClass.asJava(): DClass = copy(
     properties = properties.map { it.asJava() },
     classlikes = classlikes.map { it.asJava() },
     generics = generics.map { it.asJava() },
-    supertypes = supertypes.copy(
-        map = supertypes.mapValues { it.value.map { it.possiblyAsJava() } }
-    ),
-    modifier = if (modifier.all{(_,v) -> v is KotlinModifier.Empty}) PlatformDependent(map = platformData.map{it to JavaModifier.Final}.toMap())
-    else PlatformDependent(map = platformData.map{it to modifier.allValues.first()}.toMap())
+    supertypes = supertypes.mapValues { it.value.map { it.possiblyAsJava() } },
+    modifier = if (modifier.all{(_,v) -> v is KotlinModifier.Empty}) sourceSets.map{it to JavaModifier.Final}.toMap()
+    else sourceSets.map{it to modifier.values.first()}.toMap()
 )
 
 private fun DTypeParameter.asJava(): DTypeParameter = copy(
@@ -185,9 +176,7 @@ internal fun DEnum.asJava(): DEnum = copy(
     },
     properties = properties.map { it.asJava() },
     classlikes = classlikes.map { it.asJava() },
-    supertypes = supertypes.copy(
-        map = supertypes.mapValues { it.value.map { it.possiblyAsJava() } }
-    )
+    supertypes = supertypes.mapValues { it.value.map { it.possiblyAsJava() } }
 //    , entries = entries.map { it.asJava() }
 )
 
@@ -198,27 +187,24 @@ internal fun DObject.asJava(): DObject = copy(
     properties = properties.map { it.asJava() } +
             DProperty(
                 name = "INSTANCE",
-                modifier = PlatformDependent(map = platformData.map{it to JavaModifier.Final}.toMap()),
+                modifier = sourceSets.map{it to JavaModifier.Final}.toMap(),
                 dri = dri.copy(callable = Callable("INSTANCE", null, emptyList())),
-                documentation = PlatformDependent.empty(),
-                sources = PlatformDependent.empty(),
-                visibility = PlatformDependent(
-                    platformData.map {
-                        it to JavaVisibility.Public
-                    }.toMap()
-                ),
+                documentation = emptyMap(),
+                sources = emptyMap(),
+                visibility = sourceSets.map {
+                    it to JavaVisibility.Public
+                }.toMap(),
                 type = TypeConstructor(dri, emptyList()),
                 setter = null,
                 getter = null,
-                platformData = platformData,
+                sourceSets = sourceSets,
                 receiver = null,
                 generics = emptyList(),
+                expectPresentInSet = expectPresentInSet,
                 extra = PropertyContainer.empty<DProperty>() + AdditionalModifiers(setOf(ExtraModifiers.STATIC))
             ),
     classlikes = classlikes.map { it.asJava() },
-    supertypes = supertypes.copy(
-        map = supertypes.mapValues { it.value.map { it.possiblyAsJava() } }
-    )
+    supertypes = supertypes.mapValues { it.value.map { it.possiblyAsJava() } }
 )
 
 internal fun DInterface.asJava(): DInterface = copy(
@@ -228,9 +214,7 @@ internal fun DInterface.asJava(): DInterface = copy(
     properties = emptyList(),
     classlikes = classlikes.map { it.asJava() }, // TODO: public static final class DefaultImpls with impls for methods
     generics = generics.map { it.asJava() },
-    supertypes = supertypes.copy(
-        map = supertypes.mapValues { it.value.map { it.possiblyAsJava() } }
-    )
+    supertypes = supertypes.mapValues { it.value.map { it.possiblyAsJava() } }
 )
 
 internal fun DAnnotation.asJava(): DAnnotation = copy(
diff --git a/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt b/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt
index 66328666..d737cedb 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt
@@ -54,8 +54,8 @@ class JavaSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLogge
         }
         if (c is WithSupertypes) {
             c.supertypes.map { (p, dris) ->
-                list(dris, prefix = " extends ", platformData = setOf(p)) {
-                    link(it.sureClassNames, it, platformData = setOf(p))
+                list(dris, prefix = " extends ", sourceSets = setOf(p)) {
+                    link(it.sureClassNames, it, sourceSets = setOf(p))
                 }
             }
         }
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index dca97ec6..607a58a7 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -65,6 +65,12 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         ""
     )
 
+    override val sourceSetName: String by parser.stringOption(
+        listOf("-module"),
+        "Name of the source set",
+        "main"
+    )
+
     override val classpath: List<String> by parser.repeatableOption(
         listOf("-classpath"),
         "Classpath for symbol resolution"
@@ -75,6 +81,11 @@ class Arguments(val parser: DokkaArgumentsParser) : DokkaConfiguration.PassConfi
         "Source file or directory (allows many paths separated by the system path separator)"
     ) { SourceRootImpl(it) }
 
+    override val dependentSourceRoots: List<DokkaConfiguration.SourceRoot> by parser.repeatableOption(
+        listOf("-src"),
+        "Source file or directory (allows many paths separated by the system path separator)"
+    ) { SourceRootImpl(it) }
+
     override val samples: List<String> by parser.repeatableOption(
         listOf("-sample"),
         "Source root for samples"
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
index 24bcd96d..393a3077 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
@@ -13,72 +13,58 @@ import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.jetbrains.dokka.ReflectDsl
+import org.jetbrains.kotlin.gradle.dsl.KotlinCommonOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinSingleTargetExtension
-import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
-import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
+import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import java.io.File
 import java.io.Serializable
 
 class ConfigurationExtractor(private val project: Project) {
 
-    fun extractConfiguration(targetName: String, variantName: String?) = if (project.isMultiplatformProject()) {
-        extractFromMultiPlatform(targetName, variantName)
-    } else {
-        extractFromSinglePlatform(variantName)
-    }
-
-    fun extractFromSinglePlatform(variantName: String? = null): PlatformData? {
-        val target: KotlinTarget
-        try {
-            target = project.extensions.getByType(KotlinSingleTargetExtension::class.java).target
-        } catch (e: Throwable) {
-            when (e){
-                is UnknownDomainObjectException, is NoClassDefFoundError, is ClassNotFoundException ->
-                    return null
-                else -> throw e
+    fun extractConfiguration(targetName: String, variantName: String?) =
+        extractFromKotlinProject(targetName, variantName)
+
+    fun extractFromKotlinProject(sourceSetName: String, variantName: String?): PlatformData? {
+        val projectExtension = project.extensions.getByType(KotlinProjectExtension::class.java)
+        val sourceSet = projectExtension.sourceSets.findByName(sourceSetName)
+            ?: run { project.logger.error("No source set with name '$sourceSetName' found"); return null }
+        val compilation = when (projectExtension) {
+            is KotlinMultiplatformExtension -> projectExtension.targets.flatMap { it.compilations }
+                .first { it.kotlinSourceSets.contains(sourceSet) }
+            is KotlinSingleTargetExtension -> projectExtension.target.compilations.find {
+                it.kotlinSourceSets.contains(
+                    sourceSet
+                )
             }
-        }
-
-        return try {
-            PlatformData(null, getClasspath(target, variantName), getSourceSet(target, variantName), getPlatformName(target.platformType))
-        } catch(e: NoSuchMethodError){
-            null
-        }
+            else -> null
+        } ?: run { project.logger.error("No compilation found for set with name '$sourceSetName'"); return null }
+
+        val classpath = compilation.compileDependencyFiles.files.filter { it.exists() }
+        val dependencies = (compilation.allKotlinSourceSets - sourceSet).flatMap { it.kotlin.sourceDirectories }
+        return PlatformData(
+            sourceSetName,
+            classpath,
+            sourceSet.kotlin.sourceDirectories.filter { it.exists() }.toList(),
+            dependencies,
+            compilation.target.targetName
+        )
     }
 
-    private fun extractFromMultiPlatform(targetName: String, variantName: String?): PlatformData? =
-        try {
-            project.extensions.getByType(KotlinMultiplatformExtension::class.java).targets
-        } catch (e: Throwable) {
-            when (e){
-                is UnknownDomainObjectException, is NoClassDefFoundError, is ClassNotFoundException ->
-                    null
-                else -> throw e
-            }
-        }?.let {
-            val fixedName = if(targetName.toLowerCase() == "common") "metadata" else targetName.toLowerCase()
-            it.find { target -> target.name.toLowerCase() == fixedName }?.let { target ->
-                PlatformData(fixedName, getClasspath(target, variantName), getSourceSet(target, variantName), target.platformType.toString())
-            }
-        }
-
     fun extractFromJavaPlugin(): PlatformData? =
         project.convention.findPlugin(JavaPluginConvention::class.java)
             ?.run { sourceSets.findByName(SourceSet.MAIN_SOURCE_SET_NAME)?.allSource?.srcDirs }
-            ?.let { PlatformData(null, emptyList(), it.toList(), "") }
+            ?.let { PlatformData(null, emptyList(), it.toList(), emptyList(), "") }
 
-    fun extractFromKotlinTasks(kotlinTasks: List<Task>): PlatformData? =
+    fun extractFromKotlinTasks(passName: String, kotlinTasks: List<Task>): PlatformData? =
         try {
-            kotlinTasks.map { extractFromKotlinTask(it) }.let { platformDataList ->
-                PlatformData(null, platformDataList.flatMap { it.classpath }, platformDataList.flatMap { it.sourceRoots }, "")
-            }
+            kotlinTasks.find { it.toString() == passName }?.let { extractFromKotlinTask(it) }
         } catch (e: Throwable) {
-            when (e){
+            when (e) {
                 is UnknownDomainObjectException, is NoClassDefFoundError, is ClassNotFoundException ->
-                    extractFromKotlinTasksTheHardWay(kotlinTasks)
+                    extractFromKotlinTasksTheHardWay(passName, kotlinTasks)
                 else -> throw e
             }
         }
@@ -89,15 +75,23 @@ class ConfigurationExtractor(private val project: Project) {
                 .compilations
                 .find { it.compileKotlinTask == task }
         } catch (e: Throwable) {
-            when (e){
+            when (e) {
                 is UnknownDomainObjectException, is NoClassDefFoundError, is ClassNotFoundException ->
                     project.extensions.getByType(KotlinMultiplatformExtension::class.java).targets
                         .flatMap { it.compilations }.firstOrNull { it.compileKotlinTask == task }
                 else -> throw e
             }
-        }.let { PlatformData(task.name, getClasspath(it), getSourceSet(it), it?.platformType?.toString() ?: "") }
+        }.let {
+            PlatformData(
+                task.name,
+                getClasspath(it),
+                getSourceSet(it),
+                getDependentSourceSet(it),
+                it?.platformType?.toString() ?: ""
+            )
+        }
 
-    private fun extractFromKotlinTasksTheHardWay(kotlinTasks: List<Task>): PlatformData? {
+    private fun extractFromKotlinTasksTheHardWay(passName: String, kotlinTasks: List<Task>): PlatformData? {
         val allClasspath = mutableSetOf<File>()
         var allClasspathFileCollection: FileCollection = project.files()
         val allSourceRoots = mutableSetOf<File>()
@@ -116,8 +110,8 @@ class ConfigurationExtractor(private val project: Project) {
 
                 val taskClasspath: Iterable<File> =
                     (it["getClasspath", AbstractCompile::class].takeIfIsFunc()?.invoke()
-                            ?: it["compileClasspath", abstractKotlinCompileClz].takeIfIsProp()?.v()
-                            ?: it["getClasspath", abstractKotlinCompileClz]())
+                        ?: it["compileClasspath", abstractKotlinCompileClz].takeIfIsProp()?.v()
+                        ?: it["getClasspath", abstractKotlinCompileClz]())
 
                 if (taskClasspath is FileCollection) {
                     allClasspathFileCollection += taskClasspath
@@ -132,28 +126,35 @@ class ConfigurationExtractor(private val project: Project) {
         } catch (e: ResolveException) {
             mutableListOf()
         }
-        classpath.addAll (project.files(allClasspath).toList())
+        classpath.addAll(project.files(allClasspath).toList())
 
-        return PlatformData(null, classpath, allSourceRoots.toList(), "")
+        return PlatformData(null, classpath, allSourceRoots.toList(), emptyList(), "")
     }
 
     private fun getSourceSet(target: KotlinTarget, variantName: String? = null): List<File> =
-        if(variantName != null)
+        if (variantName != null)
             getSourceSet(getCompilation(target, variantName))
         else
             getSourceSet(getMainCompilation(target))
 
-    private fun getClasspath(target: KotlinTarget, variantName: String? = null): List<File> = if (target.isAndroidTarget()) {
-        if(variantName != null)
-            getClasspathFromAndroidTask(getCompilation(target, variantName))
-        else
-            getClasspathFromAndroidTask(getMainCompilation(target))
-    } else {
-        getClasspath(getMainCompilation(target))
-    }
+    private fun getClasspath(target: KotlinTarget, variantName: String? = null): List<File> =
+        if (target.isAndroidTarget()) {
+            if (variantName != null)
+                getClasspathFromAndroidTask(getCompilation(target, variantName))
+            else
+                getClasspathFromAndroidTask(getMainCompilation(target))
+        } else {
+            getClasspath(getMainCompilation(target))
+        }
 
     private fun getSourceSet(compilation: KotlinCompilation<*>?): List<File> = compilation
-        ?.allKotlinSourceSets
+        ?.kotlinSourceSets
+        ?.flatMap { it.kotlin.sourceDirectories }
+        ?.filter { it.exists() }
+        .orEmpty()
+
+    private fun getDependentSourceSet(compilation: KotlinCompilation<*>?): List<File> = compilation
+        ?.let { it.allKotlinSourceSets - it.kotlinSourceSets }
         ?.flatMap { it.kotlin.sourceDirectories }
         ?.filter { it.exists() }
         .orEmpty()
@@ -183,7 +184,7 @@ class ConfigurationExtractor(private val project: Project) {
 
     private fun getVariants(project: Project): Set<BaseVariant> {
         val androidExtension = project.extensions.getByName("android")
-        val baseVariants =  when (androidExtension) {
+        val baseVariants = when (androidExtension) {
             is AppExtension -> androidExtension.applicationVariants.toSet()
             is LibraryExtension -> {
                 androidExtension.libraryVariants.toSet() +
@@ -208,8 +209,11 @@ class ConfigurationExtractor(private val project: Project) {
     private fun getPlatformName(platform: KotlinPlatformType): String =
         if (platform == KotlinPlatformType.androidJvm) KotlinPlatformType.jvm.toString() else platform.toString()
 
-    data class PlatformData(val name: String?,
-                            val classpath: List<File>,
-                            val sourceRoots: List<File>,
-                            val platform: String) : Serializable
+    data class PlatformData(
+        val name: String?,
+        val classpath: List<File>,
+        val sourceRoots: List<File>,
+        val dependentSourceRoots: List<File>,
+        val platform: String
+    ) : Serializable
 }
\ 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 2018d3af..356661da 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
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka.gradle
 
-import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 import org.gradle.api.*
 import org.gradle.api.artifacts.Configuration
@@ -24,7 +23,7 @@ import java.util.function.BiConsumer
 
 open class DokkaTask : DefaultTask(), Configurable {
     private val ANDROID_REFERENCE_URL = Builder("https://developer.android.com/reference/").build()
-    private val GLOBAL_PLATFORM_NAME = "global" // Used for copying perPackageOptions to other platforms
+    private val GLOBAL_CONFIGURATION_NAME = "global" // Used for copying perPackageOptions to other platforms
 
     @Suppress("MemberVisibilityCanBePrivate")
     fun defaultKotlinTasks(): List<Task> = with(ReflectDsl) {
@@ -69,10 +68,10 @@ open class DokkaTask : DefaultTask(), Configurable {
     @Classpath
     lateinit var pluginsConfig: Configuration
 
-    var multiplatform: NamedDomainObjectContainer<GradlePassConfigurationImpl>
+    var dokkaSourceSets: NamedDomainObjectContainer<GradlePassConfigurationImpl>
         @Suppress("UNCHECKED_CAST")
-        @Nested get() = (DslObject(this).extensions.getByName(MULTIPLATFORM_EXTENSION_NAME) as NamedDomainObjectContainer<GradlePassConfigurationImpl>)
-        internal set(value) = DslObject(this).extensions.add(MULTIPLATFORM_EXTENSION_NAME, value)
+        @Nested get() = (DslObject(this).extensions.getByName(SOURCE_SETS_EXTENSION_NAME) as NamedDomainObjectContainer<GradlePassConfigurationImpl>)
+        internal set(value) = DslObject(this).extensions.add(SOURCE_SETS_EXTENSION_NAME, value)
 
     var configuration: GradlePassConfigurationImpl
         @Suppress("UNCHECKED_CAST")
@@ -188,7 +187,7 @@ open class DokkaTask : DefaultTask(), Configurable {
     }
 
     internal fun getConfiguration(): GradleDokkaConfigurationImpl {
-        val globalConfig = multiplatform.toList().find { it.name.toLowerCase() == GLOBAL_PLATFORM_NAME }
+        val globalConfig = dokkaSourceSets.toList().find { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
         val defaultModulesConfiguration = collectConfigurations()
             .map { defaultPassConfiguration(it, globalConfig) }
         return GradleDokkaConfigurationImpl().apply {
@@ -204,27 +203,28 @@ open class DokkaTask : DefaultTask(), Configurable {
     }
 
     private fun collectConfigurations() =
-        if (this.isMultiplatformProject()) collectMultiplatform() else listOf(collectSinglePlatform(configuration))
+        if (this.dokkaSourceSets.isNotEmpty()) collectMultipassConfiguration() else listOf(collectSinglePassConfiguration(configuration))
 
-    private fun collectMultiplatform() = multiplatform
-        .filterNot { it.name.toLowerCase() == GLOBAL_PLATFORM_NAME }
-        .map { collectSinglePlatform(it) }
+    private fun collectMultipassConfiguration() = dokkaSourceSets
+        .filterNot { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
+        .map { collectSinglePassConfiguration(it) }
 
-    private fun collectSinglePlatform(config: GradlePassConfigurationImpl): GradlePassConfigurationImpl {
-        val userConfig = config.let {
+    private fun collectSinglePassConfiguration(config: GradlePassConfigurationImpl): GradlePassConfigurationImpl {
+        val userConfig = config
+        /*.let {
             if (it.collectKotlinTasks != null) {
                 configExtractor.extractFromKotlinTasks(extractKotlinCompileTasks(it.collectKotlinTasks!!))
                     ?.let { platformData -> mergeUserConfigurationAndPlatformData(it, platformData) } ?: it
             } else {
                 it
             }
-        }
+        }*/
 
         if (disableAutoconfiguration) return userConfig
 
         val baseConfig = configExtractor.extractConfiguration(userConfig.name, userConfig.androidVariant)
             ?.let { mergeUserConfigurationAndPlatformData(userConfig, it) }
-            ?: if (this.isMultiplatformProject()) {
+            ?: if (this.dokkaSourceSets.isNotEmpty()) {
                 if (outputDiagnosticInfo)
                     logger.warn(
                         "Could not find target with name: ${userConfig.name} in Kotlin Gradle Plugin, " +
@@ -233,7 +233,7 @@ open class DokkaTask : DefaultTask(), Configurable {
                 userConfig
             } else {
                 logger.warn("Could not find target with name: ${userConfig.name} in Kotlin Gradle Plugin")
-                collectFromSinglePlatformOldPlugin()
+                collectFromSinglePlatformOldPlugin(userConfig.name)
             }
 
         return if (subProjects.isNotEmpty()) {
@@ -256,8 +256,8 @@ open class DokkaTask : DefaultTask(), Configurable {
         }
     }
 
-    private fun collectFromSinglePlatformOldPlugin() =
-        configExtractor.extractFromKotlinTasks(kotlinTasks)
+    private fun collectFromSinglePlatformOldPlugin(name: String) =
+        configExtractor.extractFromKotlinTasks(name, kotlinTasks)
             ?.let { mergeUserConfigurationAndPlatformData(configuration, it) }
             ?: configExtractor.extractFromJavaPlugin()
                 ?.let { mergeUserConfigurationAndPlatformData(configuration, it) }
@@ -269,6 +269,7 @@ open class DokkaTask : DefaultTask(), Configurable {
     ) =
         userConfig.copy().apply {
             sourceRoots.addAll(userConfig.sourceRoots.union(autoConfig.sourceRoots.toSourceRoots()).distinct())
+            dependentSourceRoots.addAll(userConfig.dependentSourceRoots.union(autoConfig.dependentSourceRoots.toSourceRoots()).distinct())
             classpath = userConfig.classpath.union(autoConfig.classpath.map { it.absolutePath }).distinct()
             if (userConfig.platform == null && autoConfig.platform != "")
                 platform = autoConfig.platform
@@ -281,11 +282,10 @@ open class DokkaTask : DefaultTask(), Configurable {
         if (config.moduleName == "") {
             config.moduleName = project.name
         }
-        if (config.targets.isEmpty() && multiplatform.isNotEmpty()) {
-            config.targets = listOf(config.name)
+        if (config.sourceSetName.isEmpty()) {
+            config.sourceSetName = config.platform ?: config.name
         }
-        config.classpath =
-            (config.classpath as List<Any>).map { it.toString() }.distinct() // Workaround for Groovy's GStringImpl
+        config.classpath = (config.classpath as List<Any>).map { it.toString() }.distinct() // Workaround for Groovy's GStringImpl
         config.sourceRoots = config.sourceRoots.distinct().toMutableList()
         config.samples = config.samples.map { project.file(it).absolutePath }
         config.includes = config.includes.map { project.file(it).absolutePath }
@@ -293,7 +293,7 @@ open class DokkaTask : DefaultTask(), Configurable {
         if (project.isAndroidProject() && !config.noAndroidSdkLink) { // TODO: introduce Android as a separate Dokka platform?
             config.externalDocumentationLinks.add(ANDROID_REFERENCE_URL)
         }
-        if (config.platform != null && config.platform.toString().isNotEmpty()) {
+        if (config.platform != null && config.platform.toString().isNotBlank()) {
             config.analysisPlatform = dokkaPlatformFromString(config.platform.toString())
         }
         if (globalConfig != null) {
@@ -339,5 +339,4 @@ open class DokkaTask : DefaultTask(), Configurable {
             null
         }
     }
-}
-
+}
\ No newline at end of file
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
index 570da5f3..9719686e 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
@@ -27,7 +27,9 @@ class GradleSourceRootImpl: SourceRoot, Serializable {
 open class GradlePassConfigurationImpl(@Transient val name: String = ""): PassConfiguration {
     @Input @Optional override var classpath: List<String> = emptyList()
     @Input override var moduleName: String = ""
+    @Input override var sourceSetName: String = ""
     @Input override var sourceRoots: MutableList<SourceRoot> = mutableListOf()
+    @Input override var dependentSourceRoots: MutableList<SourceRoot> = mutableListOf()
     @Input override var samples: List<String> = emptyList()
     @Input override var includes: List<String> = emptyList()
     @Input override var includeNonPublic: Boolean = false
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 1d93a310..fea0d864 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
@@ -9,7 +9,7 @@ import java.io.InputStream
 import java.util.*
 
 internal const val CONFIGURATION_EXTENSION_NAME = "configuration"
-internal const val MULTIPLATFORM_EXTENSION_NAME = "multiplatform"
+internal const val SOURCE_SETS_EXTENSION_NAME = "dokkaSourceSets"
 internal const val DOKKA_TASK_NAME = "dokka"
 internal const val DOKKA_COLLECTOR_TASK_NAME = "dokkaCollector"
 
@@ -45,7 +45,7 @@ open class DokkaPlugin : Plugin<Project> {
             project.tasks.create(DOKKA_TASK_NAME, taskClass)
         }
         project.tasks.withType(taskClass) { task ->
-            task.multiplatform = project.container(GradlePassConfigurationImpl::class.java)
+            task.dokkaSourceSets = project.container(GradlePassConfigurationImpl::class.java)
             task.configuration = GradlePassConfigurationImpl()
             task.dokkaRuntime = runtimeConfiguration
             task.pluginsConfig = pluginsConfiguration
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/utils.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/utils.kt
index 31892e8e..3369a640 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/utils.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/utils.kt
@@ -16,16 +16,4 @@ fun Project.isAndroidProject() = try {
     false
 }
 
-fun Project.isMultiplatformProject() = try {
-    project.extensions.getByType(KotlinMultiplatformExtension::class.java)
-    true
-} catch(e: UnknownDomainObjectException) {
-    false
-} catch (e: NoClassDefFoundError){
-    false
-} catch(e: ClassNotFoundException) {
-    false
-}
-
-fun KotlinTarget.isAndroidTarget() = this.platformType == KotlinPlatformType.androidJvm
-fun DokkaTask.isMultiplatformProject() = this.multiplatform.isNotEmpty()
\ No newline at end of file
+fun KotlinTarget.isAndroidTarget() = this.platformType == KotlinPlatformType.androidJvm
\ No newline at end of file
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 24d95ab4..ac22eb57 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -83,6 +83,9 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
         override var suppress: Boolean = false
     }
 
+    @Parameter(required = true, defaultValue = "\${project.sourceSet}")
+    var sourceSetName: String = ""
+
     @Parameter(required = true, defaultValue = "\${project.compileSourceRoots}")
     var sourceDirectories: List<String> = emptyList()
 
@@ -201,7 +204,9 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
 
         val passConfiguration = PassConfigurationImpl(
             classpath = classpath,
-            sourceRoots = sourceDirectories.map { SourceRootImpl(it) } + sourceRoots.map { SourceRootImpl(path = it.path) },
+            sourceSetName = sourceSetName,
+            sourceRoots = sourceDirectories.map { SourceRootImpl(it) },
+            dependentSourceRoots = sourceRoots.map { SourceRootImpl(path = it.path) },
             samples = samples,
             includes = includes,
             collectInheritedExtensionsFromLibraries = collectInheritedExtensionsFromLibraries, // TODO: Should we implement this?
diff --git a/testApi/src/main/kotlin/testApi/context/MockContext.kt b/testApi/src/main/kotlin/testApi/context/MockContext.kt
index 5236f1f4..11520280 100644
--- a/testApi/src/main/kotlin/testApi/context/MockContext.kt
+++ b/testApi/src/main/kotlin/testApi/context/MockContext.kt
@@ -2,7 +2,8 @@ package org.jetbrains.dokka.testApi.context
 
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.EnvironmentAndFacade
-import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.model.SourceSetCache
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.plugability.ExtensionPoint
@@ -15,8 +16,9 @@ import kotlin.reflect.full.memberProperties
 class MockContext(
     vararg extensions: Pair<ExtensionPoint<*>, (DokkaContext) -> Any>,
     private val testConfiguration: DokkaConfiguration? = null,
-    private val testPlatforms: Map<PlatformData, EnvironmentAndFacade>? = null,
-    private val unusedExtensionPoints: List<ExtensionPoint<*>>? = null
+    private val testSourceSets: Map<SourceSetData, EnvironmentAndFacade>? = null,
+    private val unusedExtensionPoints: List<ExtensionPoint<*>>? = null,
+    override val sourceSetCache: SourceSetCache
 ) : DokkaContext {
     private val extensionMap by lazy {
         extensions.groupBy(Pair<ExtensionPoint<*>, (DokkaContext) -> Any>::first) {
@@ -39,8 +41,8 @@ class MockContext(
     override val configuration: DokkaConfiguration
         get() = testConfiguration ?: throw IllegalStateException("This mock context doesn't provide configuration")
 
-    override val platforms: Map<PlatformData, EnvironmentAndFacade>
-        get() = testPlatforms ?: throw IllegalStateException("This mock context doesn't provide platforms data")
+    override val platforms: Map<SourceSetData, EnvironmentAndFacade>
+        get() = testSourceSets ?: throw IllegalStateException("This mock context doesn't provide platforms data")
     override val unusedPoints: Collection<ExtensionPoint<*>>
         get() = unusedExtensionPoints
             ?: throw IllegalStateException("This mock context doesn't provide unused extension points")
diff --git a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
index 0e77344d..802bfd93 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
@@ -3,7 +3,8 @@ package org.jetbrains.dokka.testApi.testRunner
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.DokkaGenerator
 import org.jetbrains.dokka.EnvironmentAndFacade
-import org.jetbrains.dokka.pages.PlatformData
+import org.jetbrains.dokka.model.SourceSetCache
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
 
@@ -16,11 +17,15 @@ internal class DokkaTestGenerator(
 
     fun generate() = with(testMethods) {
         val dokkaGenerator = DokkaGenerator(configuration, logger)
+        val sourceSetsCache = SourceSetCache()
 
-        val platforms: Map<PlatformData, EnvironmentAndFacade> = dokkaGenerator.setUpAnalysis(configuration)
+        val platforms: Map<SourceSetData, EnvironmentAndFacade> = dokkaGenerator.setUpAnalysis(
+            configuration,
+            sourceSetsCache
+        )
         analysisSetupStage(platforms)
 
-        val context = dokkaGenerator.initializePlugins(configuration, logger, platforms, pluginOverrides)
+        val context = dokkaGenerator.initializePlugins(configuration, logger, platforms, sourceSetsCache, pluginOverrides)
         pluginsSetupStage(context)
 
         val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(platforms, context)
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index 6c132d3c..43d99dad 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -3,8 +3,8 @@ package org.jetbrains.dokka.testApi.testRunner
 import com.intellij.openapi.application.PathManager
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.model.DModule
+import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.ModulePageNode
-import org.jetbrains.dokka.pages.PlatformData
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
@@ -104,7 +104,7 @@ abstract class AbstractCoreTest {
     }
 
     protected class TestBuilder {
-        var analysisSetupStage: (Map<PlatformData, EnvironmentAndFacade>) -> Unit = {}
+        var analysisSetupStage: (Map<SourceSetData, EnvironmentAndFacade>) -> Unit = {}
         var pluginsSetupStage: (DokkaContext) -> Unit = {}
         var documentablesCreationStage: (List<DModule>) -> Unit = {}
         var documentablesFirstTransformationStep: (List<DModule>) -> Unit = {}
@@ -167,8 +167,10 @@ abstract class AbstractCoreTest {
     @DokkaConfigurationDsl
     protected class DokkaPassConfigurationBuilder(
         var moduleName: String = "root",
+        var sourceSetName: String = "main",
         var classpath: List<String> = emptyList(),
         var sourceRoots: List<String> = emptyList(),
+        var dependentSourceRoots: List<String> = emptyList(),
         var samples: List<String> = emptyList(),
         var includes: List<String> = emptyList(),
         var includeNonPublic: Boolean = true,
@@ -192,8 +194,10 @@ abstract class AbstractCoreTest {
     ) {
         fun build() = PassConfigurationImpl(
             moduleName = moduleName,
+            sourceSetName = sourceSetName,
             classpath = classpath,
             sourceRoots = sourceRoots.map { SourceRootImpl(it) },
+            dependentSourceRoots = dependentSourceRoots.map { SourceRootImpl(it) },
             samples = samples,
             includes = includes,
             includeNonPublic = includeNonPublic,
@@ -235,7 +239,7 @@ abstract class AbstractCoreTest {
 }
 
 data class TestMethods(
-    val analysisSetupStage: (Map<PlatformData, EnvironmentAndFacade>) -> Unit,
+    val analysisSetupStage: (Map<SourceSetData, EnvironmentAndFacade>) -> Unit,
     val pluginsSetupStage: (DokkaContext) -> Unit,
     val documentablesCreationStage: (List<DModule>) -> Unit,
     val documentablesFirstTransformationStep: (List<DModule>) -> Unit,
-- 
cgit 


From 08f40e2a13006882e8f8425f111b8527e7bbcb0f Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Wed, 24 Jun 2020 09:14:37 +0200
Subject: Remove kotlin source analysis from :core to :kotlin-analysis (thanks
 to Afzal Najam)

---
 core/build.gradle.kts                              |   7 +-
 core/dependencies/build.gradle.kts                 |  40 ++
 core/src/main/kotlin/DokkaGenerator.kt             |  83 +--
 .../main/kotlin/analysis/AnalysisEnvironment.kt    | 625 --------------------
 .../main/kotlin/analysis/CoreKotlinCacheService.kt |  42 --
 .../main/kotlin/analysis/CoreProjectFileIndex.kt   | 569 ------------------
 .../main/kotlin/analysis/JavaResolveExtension.kt   | 128 -----
 core/src/main/kotlin/links/DRI.kt                  | 132 +----
 core/src/main/kotlin/model/Documentable.kt         |  12 +-
 .../kotlin/model/properties/PropertyContainer.kt   |   4 +-
 core/src/main/kotlin/parsers/HtmlParser.kt         |  89 ---
 core/src/main/kotlin/parsers/MarkdownParser.kt     | 418 --------------
 core/src/main/kotlin/parsers/Parser.kt             |  42 --
 .../factories/DocTagsFromIElementFactory.kt        |  43 --
 .../parsers/factories/DocTagsFromStringFactory.kt  |  77 ---
 core/src/main/kotlin/plugability/DokkaContext.kt   |   7 +-
 core/src/main/kotlin/plugability/DokkaPlugin.kt    |   6 +-
 core/src/main/kotlin/utilities/cast.kt             |   5 +
 coreDependencies/build.gradle.kts                  |  65 ---
 .../gradle-integration-tests/build.gradle.kts      |   2 +-
 kotlin-analysis/build.gradle.kts                   |  27 +
 kotlin-analysis/dependencies/build.gradle.kts      |  67 +++
 .../dokka/analysis/AnalysisEnvironment.kt          | 636 +++++++++++++++++++++
 .../jetbrains/dokka/analysis/CallableFactory.kt    |  31 +
 .../dokka/analysis/CoreKotlinCacheService.kt       |  42 ++
 .../dokka/analysis/CoreProjectFileIndex.kt         | 515 +++++++++++++++++
 .../org/jetbrains/dokka/analysis/DRIFactory.kt     |  38 ++
 .../jetbrains/dokka/analysis/DRITargetFactory.kt   |  44 ++
 .../org/jetbrains/dokka/analysis/Documentable.kt   |  14 +
 .../dokka/analysis/EnvironmentAndFacade.kt         |  59 ++
 .../dokka/analysis/JavaResolveExtension.kt         | 128 +++++
 .../org/jetbrains/dokka/analysis/KotlinAnalysis.kt |  46 ++
 .../dokka/analysis/TypeReferenceFactory.kt         |  51 ++
 plugins/base/build.gradle.kts                      |   1 +
 plugins/base/src/main/kotlin/DokkaBase.kt          |  21 +-
 .../kotlin/allModulePage/MultimodulePageCreator.kt |   2 +-
 plugins/base/src/main/kotlin/parsers/HtmlParser.kt |  89 +++
 .../base/src/main/kotlin/parsers/MarkdownParser.kt | 419 ++++++++++++++
 plugins/base/src/main/kotlin/parsers/Parser.kt     |  42 ++
 .../factories/DocTagsFromIElementFactory.kt        |  43 ++
 .../parsers/factories/DocTagsFromStringFactory.kt  |  77 +++
 .../ModuleAndPackageDocumentationTransformer.kt    |  20 +-
 .../documentables/ReportUndocumentedTransformer.kt |   1 +
 .../pages/samples/SamplesTransformer.kt            |  41 +-
 .../pages/sourcelinks/SourceLinksTransformer.kt    |   4 +-
 .../DefaultDescriptorToDocumentableTranslator.kt   |  13 +-
 .../psi/DefaultPsiToDocumentableTranslator.kt      |  23 +-
 .../main/kotlin/translators/psi/JavadocParser.kt   |   1 +
 .../src/test/kotlin/basic/FailOnWarningTest.kt     |   6 +-
 plugins/build.gradle.kts                           |   3 +-
 .../main/kotlin/javadoc/pages/JavadocPageNodes.kt  |   3 +
 .../javadoc/src/test/kotlin/javadoc/JavadocTest.kt |   2 +-
 runners/cli/build.gradle.kts                       |   1 +
 runners/cli/src/main/kotlin/cli/main.kt            |   2 +-
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |   6 +-
 settings.gradle.kts                                |   6 +-
 test-tools/build.gradle.kts                        |   1 +
 testApi/build.gradle.kts                           |   2 +
 .../src/main/kotlin/testApi/context/MockContext.kt |   4 -
 .../testApi/testRunner/DokkaTestGenerator.kt       |  11 +-
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |   3 -
 61 files changed, 2545 insertions(+), 2396 deletions(-)
 create mode 100644 core/dependencies/build.gradle.kts
 delete mode 100644 core/src/main/kotlin/analysis/AnalysisEnvironment.kt
 delete mode 100644 core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
 delete mode 100644 core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
 delete mode 100644 core/src/main/kotlin/analysis/JavaResolveExtension.kt
 delete mode 100644 core/src/main/kotlin/parsers/HtmlParser.kt
 delete mode 100644 core/src/main/kotlin/parsers/MarkdownParser.kt
 delete mode 100644 core/src/main/kotlin/parsers/Parser.kt
 delete mode 100644 core/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
 delete mode 100644 core/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt
 create mode 100644 core/src/main/kotlin/utilities/cast.kt
 delete mode 100644 coreDependencies/build.gradle.kts
 create mode 100644 kotlin-analysis/build.gradle.kts
 create mode 100644 kotlin-analysis/dependencies/build.gradle.kts
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CallableFactory.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CoreKotlinCacheService.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CoreProjectFileIndex.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DRIFactory.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DRITargetFactory.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/Documentable.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/JavaResolveExtension.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
 create mode 100644 kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/TypeReferenceFactory.kt
 create mode 100644 plugins/base/src/main/kotlin/parsers/HtmlParser.kt
 create mode 100644 plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
 create mode 100644 plugins/base/src/main/kotlin/parsers/Parser.kt
 create mode 100644 plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
 create mode 100644 plugins/base/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 1d61e410..fc62b73d 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -6,12 +6,9 @@ plugins {
 }
 
 dependencies {
-    api(project(":coreDependencies", configuration = "shadow"))
+    api(project("dependencies", configuration = "shadow"))
 
-    val kotlin_version: String by project
-    api("org.jetbrains.kotlin:kotlin-compiler:$kotlin_version")
-    implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
-    implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlin_version")
+    implementation(kotlin("reflect"))
     implementation("com.google.code.gson:gson:2.8.5")
     implementation("org.jsoup:jsoup:1.12.1")
 
diff --git a/core/dependencies/build.gradle.kts b/core/dependencies/build.gradle.kts
new file mode 100644
index 00000000..a26d109e
--- /dev/null
+++ b/core/dependencies/build.gradle.kts
@@ -0,0 +1,40 @@
+import org.jetbrains.configureBintrayPublication
+
+plugins {
+    id("com.github.johnrengelman.shadow")
+    `maven-publish`
+    id("com.jfrog.bintray")
+}
+
+repositories {
+    maven(url = "https://kotlin.bintray.com/kotlin-plugin")
+}
+
+dependencies {
+    // TODO (see https://github.com/Kotlin/dokka/issues/1009)
+    implementation(kotlin("stdlib"))
+    implementation(kotlin("reflect"))
+
+    implementation("org.jetbrains:markdown:0.1.41") {
+        because("it's published only on bintray")
+    }
+}
+
+tasks {
+    shadowJar {
+        val dokka_version: String by project
+        archiveFileName.set("dokka-dependencies-$dokka_version.jar")
+        archiveClassifier.set("")
+    }
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("dokkaCoreDependencies") {
+            artifactId = "dokka-core-dependencies"
+            project.shadow.component(this)
+        }
+    }
+}
+
+configureBintrayPublication("dokkaCoreDependencies")
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index b2e572d4..b88c6223 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,7 +1,5 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.analysis.AnalysisEnvironment
-import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.model.SourceSetCache
 import org.jetbrains.dokka.model.SourceSetData
@@ -9,13 +7,7 @@ import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 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.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.utils.PathUtil
-import java.io.File
+
 
 /**
  * DokkaGenerator is the main entry point for generating documentation
@@ -26,15 +18,13 @@ class DokkaGenerator(
     private val logger: DokkaLogger
 ) {
     fun generate() = timed {
-        report("Setting up analysis environments")
         val sourceSetsCache = SourceSetCache()
-        val sourceSets: Map<SourceSetData, EnvironmentAndFacade> = setUpAnalysis(configuration, sourceSetsCache)
 
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, sourceSets, sourceSetsCache)
+        val context = initializePlugins(configuration, logger, sourceSetsCache)
 
         report("Creating documentation models")
-        val modulesFromPlatforms = createDocumentationModels(sourceSets, context)
+        val modulesFromPlatforms = createDocumentationModels(context, sourceSetsCache)
 
         report("Transforming documentation model before merging")
         val transformedDocumentationBeforeMerge = transformDocumentationModelBeforeMerge(modulesFromPlatforms, context)
@@ -59,9 +49,8 @@ class DokkaGenerator(
 
     fun generateAllModulesPage() = timed {
         val sourceSetsCache = SourceSetCache()
-        val sourceSets = emptyMap<SourceSetData, EnvironmentAndFacade>()
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, sourceSets, sourceSetsCache)
+        val context = initializePlugins(configuration, logger, sourceSetsCache)
 
         report("Creating all modules page")
         val pages = createAllModulePage(context)
@@ -73,26 +62,20 @@ class DokkaGenerator(
         render(transformedPages, context)
     }.dump("\n\n === TIME MEASUREMENT ===\n")
 
-    fun setUpAnalysis(
-        configuration: DokkaConfiguration,
-        sourceSetsCache: SourceSetCache
-    ): Map<SourceSetData, EnvironmentAndFacade> =
-        configuration.passesConfigurations.map {
-            sourceSetsCache.getSourceSet(it) to createEnvironmentAndFacade(configuration, it)
-        }.toMap()
 
     fun initializePlugins(
         configuration: DokkaConfiguration,
         logger: DokkaLogger,
-        sourceSets: Map<SourceSetData, EnvironmentAndFacade>,
         sourceSetsCache: SourceSetCache,
         pluginOverrides: List<DokkaPlugin> = emptyList()
-    ) = DokkaContext.create(configuration, logger, sourceSets, sourceSetsCache, pluginOverrides)
+    ) = DokkaContext.create(configuration, logger, sourceSetsCache, pluginOverrides)
 
     fun createDocumentationModels(
-        platforms: Map<SourceSetData, EnvironmentAndFacade>,
-        context: DokkaContext
-    ) = platforms.flatMap { (pdata, _) -> translateSources(pdata, context) }
+        context: DokkaContext,
+        sourceSetsCache: SourceSetCache
+    ) = context.configuration.passesConfigurations
+        .map { passConfiguration -> sourceSetsCache.getSourceSet(passConfiguration) }
+        .flatMap { passConfiguration -> translateSources(passConfiguration, context) }
 
     fun transformDocumentationModelBeforeMerge(
         modulesFromPlatforms: List<DModule>,
@@ -150,56 +133,10 @@ class DokkaGenerator(
         }
     }
 
-    private fun createEnvironmentAndFacade(
-        configuration: DokkaConfiguration,
-        pass: DokkaConfiguration.PassConfiguration
-    ): EnvironmentAndFacade =
-        AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
-            if (analysisPlatform == Platform.jvm) {
-                addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
-            }
-            pass.classpath.forEach { addClasspath(File(it)) }
-
-            addSources(
-                (pass.sourceRoots + configuration.passesConfigurations.filter { it.sourceSetID in pass.dependentSourceSets }
-                    .flatMap { it.sourceRoots })
-                    .map { it.path }
-            )
-
-            loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
-
-            val environment = createCoreEnvironment()
-            val (facade, _) = createResolutionFacade(environment)
-            EnvironmentAndFacade(environment, facade)
-        }
-
     private fun translateSources(platformData: SourceSetData, context: DokkaContext) =
         context[CoreExtensions.sourceToDocumentableTranslator].map {
             it.invoke(platformData, context)
         }
-
-    class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
-        override fun clear() {
-            seenErrors = false
-        }
-
-        private var seenErrors = false
-
-        override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
-            if (severity == CompilerMessageSeverity.ERROR) {
-                seenErrors = true
-            }
-            logger.info(MessageRenderer.PLAIN_FULL_PATHS.render(severity, message, location))
-        }
-
-        override fun hasErrors() = seenErrors
-    }
-}
-
-// It is not data class due to ill-defined equals
-class EnvironmentAndFacade(val environment: KotlinCoreEnvironment, val facade: DokkaResolutionFacade) {
-    operator fun component1() = environment
-    operator fun component2() = facade
 }
 
 private class Timer(startTime: Long, private val logger: DokkaLogger?) {
diff --git a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
deleted file mode 100644
index 33451dd6..00000000
--- a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
+++ /dev/null
@@ -1,625 +0,0 @@
-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.MockComponentManager
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.extensions.Extensions
-import com.intellij.openapi.module.Module
-import com.intellij.openapi.module.ModuleManager
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.OrderEnumerationHandler
-import com.intellij.openapi.roots.ProjectFileIndex
-import com.intellij.openapi.roots.ProjectRootManager
-import com.intellij.openapi.util.Disposer
-import com.intellij.openapi.vfs.StandardFileSystems
-import com.intellij.psi.PsiElement
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.dokka.Platform
-import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters
-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.resolve.*
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.config.ContentRoot
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
-import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.cli.jvm.config.*
-import org.jetbrains.kotlin.cli.jvm.index.JavaRoot
-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.analyzer.NativeResolverForModuleFactory
-import org.jetbrains.kotlin.js.config.JSConfigurationKeys
-import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
-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.psi.*
-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.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.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.descriptors.konan.KlibModuleOrigin
-import org.jetbrains.kotlin.extensions.ApplicationExtensionDescriptor
-import org.jetbrains.kotlin.ide.konan.NativePlatformKindResolution
-import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaClass
-import org.jetbrains.kotlin.platform.IdePlatformKind
-import org.jetbrains.kotlin.platform.impl.CommonIdePlatformKind
-import org.jetbrains.kotlin.platform.impl.JsIdePlatformKind
-import org.jetbrains.kotlin.platform.impl.JvmIdePlatformKind
-import org.jetbrains.kotlin.platform.impl.NativeIdePlatformKind
-import org.jetbrains.kotlin.platform.konan.NativePlatforms
-import java.io.File
-
-const val JAR_SEPARATOR = "!/"
-const val KLIB_EXTENSION = "klib"
-
-/**
- * Kotlin as a service entry point
- *
- * Configures environment, analyses files and provides facilities to perform code processing without emitting bytecode
- *
- * $messageCollector: required by compiler infrastructure and will receive all compiler messages
- * $body: optional and can be used to configure environment without creating local variable
- */
-class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPlatform: Platform) : Disposable {
-    val configuration = CompilerConfiguration()
-
-    init {
-        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
-    }
-
-    fun createCoreEnvironment(): KotlinCoreEnvironment {
-        System.setProperty("idea.io.use.nio2", "true")
-
-        val configFiles = when (analysisPlatform) {
-            Platform.jvm, Platform.common -> EnvironmentConfigFiles.JVM_CONFIG_FILES
-            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 moduleManager = object : CoreModuleManager(environment.project, this) {
-            override fun getModules(): Array<out Module> = arrayOf(projectFileIndex.module)
-        }
-
-        CoreApplicationEnvironment.registerComponentInstance(
-            projectComponentManager.picoContainer,
-            ModuleManager::class.java, moduleManager
-        )
-
-        CoreApplicationEnvironment.registerExtensionPoint(
-            Extensions.getRootArea(),
-            OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java
-        )
-
-        projectComponentManager.registerService(
-            ProjectFileIndex::class.java,
-            projectFileIndex
-        )
-
-        projectComponentManager.registerService(
-            ProjectRootManager::class.java,
-            CoreProjectRootManager(projectFileIndex)
-        )
-
-        registerExtensionPoint(
-            ApplicationExtensionDescriptor("org.jetbrains.kotlin.idePlatformKind", IdePlatformKind::class.java),
-            listOf(
-                CommonIdePlatformKind,
-                JvmIdePlatformKind,
-                JsIdePlatformKind,
-                NativeIdePlatformKind
-            )
-        )
-
-        registerExtensionPoint(
-            IdePlatformKindResolution.Companion,
-            listOf(
-                CommonPlatformKindResolution(),
-                JvmPlatformKindResolution(),
-                JsPlatformKindResolution(),
-                NativePlatformKindResolution()
-            )
-        )
-
-        return environment
-    }
-
-    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()
-            )
-        }
-
-    fun createResolutionFacade(environment: KotlinCoreEnvironment): Pair<DokkaResolutionFacade, DokkaResolutionFacade> {
-        val projectContext = ProjectContext(environment.project, "Dokka")
-        val sourceFiles = environment.getSourceFiles()
-
-
-        val targetPlatform = when (analysisPlatform) {
-            Platform.js -> JsPlatforms.defaultJsPlatform
-            Platform.common -> CommonPlatforms.defaultCommonPlatform
-            Platform.native -> NativePlatforms.unspecifiedNativePlatform
-            Platform.jvm -> JvmPlatforms.defaultJvmPlatform
-        }
-
-        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 val platform: TargetPlatform = targetPlatform
-            override fun dependencies(): List<ModuleInfo> = listOf(this, library) + nativeLibraries
-        }
-
-        val sourcesScope = createSourceModuleSearchScope(environment.project, sourceFiles)
-        val modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo> = {
-            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")
-            }
-        }
-
-        var builtIns: JvmBuiltIns? = null
-
-        val resolverForProject = when (analysisPlatform) {
-            Platform.jvm -> {
-                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.js -> createJsResolverForProject(projectContext, module, library, modulesContent)
-            Platform.native -> createNativeResolverForProject(projectContext, module, library, modulesContent)
-
-        }
-        val libraryModuleDescriptor = resolverForProject.descriptorForModule(library)
-        val moduleDescriptor = resolverForProject.descriptorForModule(module)
-        builtIns?.initialize(moduleDescriptor, true)
-
-        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))
-
-        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 = 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 + (KlibModuleOrigin.CAPABILITY to kotlinLibrary)
-        }
-    }
-
-    private fun createCommonResolverForProject(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
-        environment: KotlinCoreEnvironment
-    ): 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(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
-    ): 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(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
-    ): 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 {
-
-                return NativeResolverForModuleFactory(
-                    PlatformAnalysisParameters.Empty,
-                    CompilerEnvironment,
-                    NativePlatforms.unspecifiedNativePlatform
-                ).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(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
-        sourcesScope: GlobalSearchScope,
-        builtIns: KotlinBuiltIns
-    ): ResolverForProject<ModuleInfo> {
-        val javaRoots = classpath
-            .mapNotNull {
-                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 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")
-                }
-
-            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = builtIns
-
-            override fun createResolverForModule(
-                descriptor: ModuleDescriptor,
-                moduleInfo: ModuleInfo
-            ): ResolverForModule = JvmResolverForModuleFactory(
-                JvmPlatformParameters({ content ->
-                    JvmPackagePartProvider(
-                        configuration.languageVersionSettings,
-                        content.moduleContentScope
-                    )
-                        .apply {
-                            addRoots(javaRoots, messageCollector)
-                        }
-                }, {
-                    val file =  (it as? BinaryJavaClass)?.virtualFile ?: (it as JavaClassImpl).psi.containingFile.virtualFile
-                    if (file in sourcesScope)
-                        module
-                    else
-                        library
-                }),
-                CompilerEnvironment,
-                unspecifiedJvmPlatform
-            ).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)
-        configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
-    }
-
-    /**
-     * Classpath for this environment.
-     */
-    val classpath: List<File>
-        get() = configuration.jvmClasspathRoots
-
-    /**
-     * Adds list of paths to classpath.
-     * $paths: collection of files to add
-     */
-    fun addClasspath(paths: List<File>) {
-        if (analysisPlatform == Platform.js) {
-            configuration.addAll(JSConfigurationKeys.LIBRARIES, paths.map { it.absolutePath })
-        }
-        configuration.addJvmClasspathRoots(paths)
-    }
-
-    /**
-     * Adds path to classpath.
-     * $path: path to add
-     */
-    fun addClasspath(path: File) {
-        if (analysisPlatform == Platform.js) {
-            configuration.add(JSConfigurationKeys.LIBRARIES, path.absolutePath)
-        }
-        configuration.addJvmClasspathRoot(path)
-    }
-
-    /**
-     * List of source roots for this environment.
-     */
-    val sources: List<String>
-        get() = configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
-            ?.filterIsInstance<KotlinSourceRoot>()
-            ?.map { it.path } ?: emptyList()
-
-    /**
-     * Adds list of paths to source roots.
-     * $list: collection of files to add
-     */
-    fun addSources(list: List<String>) {
-        list.forEach {
-            configuration.addKotlinSourceRoot(it)
-            val file = File(it)
-            if (file.isDirectory || file.extension == ".java") {
-                configuration.addJavaSourceRoot(file)
-            }
-        }
-    }
-
-    fun addRoots(list: List<ContentRoot>) {
-        configuration.addAll(CLIConfigurationKeys.CONTENT_ROOTS, list)
-    }
-
-    /**
-     * Disposes the environment and frees all associated resources.
-     */
-    override fun dispose() {
-        Disposer.dispose(this)
-    }
-
-    companion object {
-        private fun <T : Any> registerExtensionPoint(
-            appExtension: ApplicationExtensionDescriptor<T>,
-            instances: List<T>
-        ) {
-            if (Extensions.getRootArea().hasExtensionPoint(appExtension.extensionPointName))
-                return
-
-            appExtension.registerExtensionPoint()
-            instances.forEach(appExtension::registerExtension)
-        }
-    }
-}
-
-fun contentRootFromPath(path: String): ContentRoot {
-    val file = File(path)
-    return if (file.extension == "java") JavaSourceRoot(file, null) else KotlinSourceRoot(path, false)
-}
-
-
-class DokkaResolutionFacade(
-    override val project: Project,
-    override val moduleDescriptor: ModuleDescriptor,
-    val resolverForModule: ResolverForModule
-) : ResolutionFacade {
-    override fun analyzeWithAllCompilerChecks(elements: Collection<KtElement>): AnalysisResult {
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> tryGetFrontendService(element: PsiElement, serviceClass: Class<T>): T? {
-        return resolverForModule.componentProvider.tryGetService(serviceClass)
-    }
-
-    override fun resolveToDescriptor(
-        declaration: KtDeclaration,
-        bodyResolveMode: BodyResolveMode
-    ): DeclarationDescriptor {
-        return resolveSession.resolveToDescriptor(declaration)
-    }
-
-    override fun analyze(elements: Collection<KtElement>, bodyResolveMode: BodyResolveMode): BindingContext {
-        throw UnsupportedOperationException()
-    }
-
-    val resolveSession: ResolveSession get() = getFrontendService(ResolveSession::class.java)
-
-    override fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
-        if (element is KtDeclaration) {
-            val descriptor = resolveToDescriptor(element)
-            return object : BindingContext {
-                override fun <K : Any?, V : Any?> getKeys(p0: WritableSlice<K, V>?): Collection<K> {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun getType(p0: KtExpression): KotlinType? {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun <K : Any?, V : Any?> get(slice: ReadOnlySlice<K, V>?, key: K): V? {
-                    if (key != element) {
-                        throw UnsupportedOperationException()
-                    }
-                    return when {
-                        slice == BindingContext.DECLARATION_TO_DESCRIPTOR -> descriptor as V
-                        slice == BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER && (element as KtParameter).hasValOrVar() -> descriptor as V
-                        else -> null
-                    }
-                }
-
-                override fun getDiagnostics(): Diagnostics {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun addOwnDataTo(p0: BindingTrace, p1: Boolean) {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun <K : Any?, V : Any?> getSliceContents(p0: ReadOnlySlice<K, V>): ImmutableMap<K, V> {
-                    throw UnsupportedOperationException()
-                }
-
-            }
-        }
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> getFrontendService(element: PsiElement, serviceClass: Class<T>): T {
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> getFrontendService(serviceClass: Class<T>): T {
-        return resolverForModule.componentProvider.getService(serviceClass)
-    }
-
-    override fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
-        return resolverForModule.componentProvider.getService(serviceClass)
-    }
-
-    override fun <T : Any> getIdeService(serviceClass: Class<T>): T {
-        throw UnsupportedOperationException()
-    }
-
-}
diff --git a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt b/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
deleted file mode 100644
index bcf91225..00000000
--- a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.jetbrains.dokka.analysis
-
-import com.intellij.psi.PsiFile
-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.diagnostics.KotlinSuppressCache
-
-
-class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade) : KotlinCacheService {
-    override fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
-        return resolutionFacade
-    }
-
-    override fun getResolutionFacade(
-        elements: List<KtElement>,
-        platform: org.jetbrains.kotlin.platform.TargetPlatform
-    ): ResolutionFacade {
-        return 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
-    }
-
-    override fun getSuppressionCache(): KotlinSuppressCache {
-        throw UnsupportedOperationException()
-    }
-
-}
-
diff --git a/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt b/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
deleted file mode 100644
index 45138e39..00000000
--- a/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
+++ /dev/null
@@ -1,569 +0,0 @@
-package org.jetbrains.dokka.analysis
-
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.components.BaseComponent
-import com.intellij.openapi.extensions.ExtensionPointName
-import com.intellij.openapi.module.Module
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.projectRoots.Sdk
-import com.intellij.openapi.projectRoots.SdkAdditionalData
-import com.intellij.openapi.projectRoots.SdkModificator
-import com.intellij.openapi.projectRoots.SdkTypeId
-import com.intellij.openapi.roots.*
-import com.intellij.openapi.roots.impl.ProjectOrderEnumerator
-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
-import com.intellij.util.messages.MessageBus
-import org.jetbrains.jps.model.module.JpsModuleSourceRootType
-import org.jetbrains.kotlin.cli.common.config.ContentRoot
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
-import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
-import org.picocontainer.PicoContainer
-import java.io.File
-
-/**
- * Workaround for the lack of ability to create a ProjectFileIndex implementation using only
- * classes from projectModel-{api,impl}.
- */
-class CoreProjectFileIndex(private val project: Project, contentRoots: List<ContentRoot>) : ProjectFileIndex, ModuleFileIndex {
-    override fun iterateContent(p0: ContentIterator, p1: VirtualFileFilter?): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator, p2: VirtualFileFilter?): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInLibrary(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    val sourceRoots = contentRoots.filter { it !is JvmClasspathRoot }
-    val classpathRoots = contentRoots.filterIsInstance<JvmClasspathRoot>()
-
-    val module: Module = object : UserDataHolderBase(), Module {
-        override fun isDisposed(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOptionValue(p0: String): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun clearOption(p0: String) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getName(): String = "<Dokka module>"
-
-        override fun getModuleWithLibrariesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependentsScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleContentScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isLoaded(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun setOption(p0: String, p1: String?) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependenciesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependenciesAndLibrariesScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getProject(): Project = this@CoreProjectFileIndex.project
-
-        override fun getModuleContentWithDependenciesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleFilePath(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleTestsWithDependentsScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleRuntimeScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleFile(): VirtualFile? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getExtensions(p0: ExtensionPointName<T>): Array<out T> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getComponent(p0: String): BaseComponent? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponent(p0: Class<T>, p1: T): T {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponent(interfaceClass: Class<T>): T? {
-            if (interfaceClass == ModuleRootManager::class.java) {
-                return moduleRootManager as T
-            }
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDisposed(): Condition<*> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponents(p0: Class<T>): Array<out T> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getPicoContainer(): PicoContainer {
-            throw UnsupportedOperationException()
-        }
-
-        override fun hasComponent(p0: Class<*>): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getMessageBus(): MessageBus {
-            throw UnsupportedOperationException()
-        }
-
-        override fun dispose() {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val sdk: Sdk = object : Sdk, RootProvider {
-        override fun getFiles(rootType: OrderRootType): Array<out VirtualFile> = classpathRoots
-                .mapNotNull { StandardFileSystems.local().findFileByPath(it.file.path) }
-                .toTypedArray()
-
-        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener, p1: Disposable) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun removeRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkModificator(): SdkModificator {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getName(): String = "<dokka SDK>"
-
-        override fun getRootProvider(): RootProvider = this
-
-        override fun getHomePath(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getVersionString(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkAdditionalData(): SdkAdditionalData? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun clone(): Any {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkType(): SdkTypeId {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getHomeDirectory(): VirtualFile? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getUserData(p0: Key<T>): T? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> putUserData(p0: Key<T>, p1: T?) {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val moduleSourceOrderEntry = object : ModuleSourceOrderEntry {
-        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
-            throw UnsupportedOperationException()
-        }
-
-
-        override fun getPresentableName(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOwnerModule(): Module = module
-
-
-        override fun isValid(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun compareTo(other: OrderEntry?): Int {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootModel(): ModuleRootModel = moduleRootManager
-
-        override fun isSynthetic(): Boolean {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val sdkOrderEntry = object : JdkOrderEntry {
-        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getJdkName(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getJdk(): Sdk = sdk
-
-        override fun getPresentableName(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOwnerModule(): Module {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isValid(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootFiles(p0: OrderRootType): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootUrls(p0: OrderRootType): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun compareTo(other: OrderEntry?): Int {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isSynthetic(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-    }
-
-    inner class MyModuleRootManager : ModuleRootManager() {
-        override fun getExternalSource(): ProjectModelExternalSource? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getExcludeRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentEntries(): Array<out ContentEntry> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getExcludeRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> processOrder(p0: RootPolicy<R>, p1: R): R {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: Boolean): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: JpsModuleSourceRootType<*>): MutableList<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun orderEntries(): OrderEnumerator =
-                ProjectOrderEnumerator(project, null).using(object : RootModelProvider {
-                    override fun getModules(): Array<out Module> = arrayOf(module)
-
-                    override fun getRootModel(p0: Module): ModuleRootModel = this@MyModuleRootManager
-                })
-
-        override fun <T : Any?> getModuleExtension(p0: Class<T>): T {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDependencyModuleNames(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModule(): Module = this@CoreProjectFileIndex.module
-
-        override fun isSdkInherited(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOrderEntries(): Array<out OrderEntry> = arrayOf(moduleSourceOrderEntry, sdkOrderEntry)
-
-        override fun getSourceRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRootUrls(p0: Boolean): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdk(): Sdk? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleDependencies(): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleDependencies(p0: Boolean): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModifiableModel(): ModifiableRootModel {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isDependsOn(p0: Module): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getFileIndex(): ModuleFileIndex {
-            return this@CoreProjectFileIndex
-        }
-
-        override fun getDependencies(): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDependencies(p0: Boolean): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    val moduleRootManager = MyModuleRootManager()
-
-    override fun getContentRootForFile(p0: VirtualFile): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootForFile(p0: VirtualFile, p1: Boolean): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getPackageNameByDirectory(p0: VirtualFile): String? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInLibrarySource(file: VirtualFile): Boolean = false
-
-    override fun getClassRootForFile(file: VirtualFile): VirtualFile? =
-        classpathRoots.firstOrNull { it.contains(file) }?.let { StandardFileSystems.local().findFileByPath(it.file.path) }
-
-    override fun getOrderEntriesForFile(file: VirtualFile): List<OrderEntry> =
-        if (classpathRoots.contains(file)) listOf(sdkOrderEntry) else emptyList()
-
-    override fun isInLibraryClasses(file: VirtualFile): Boolean = classpathRoots.contains(file)
-
-    override fun isExcluded(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getSourceRootForFile(p0: VirtualFile): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isUnderIgnored(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isLibraryClassFile(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getModuleForFile(file: VirtualFile): Module? =
-            if (sourceRoots.contains(file)) module else null
-
-    private fun List<ContentRoot>.contains(file: VirtualFile): Boolean = any { it.contains(file) }
-
-    override fun getModuleForFile(p0: VirtualFile, p1: Boolean): Module? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInSource(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isIgnored(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isContentSourceFile(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInSourceContent(file: VirtualFile): Boolean = sourceRoots.contains(file)
-
-    override fun iterateContent(p0: ContentIterator): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInContent(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInTestSourceContent(file: VirtualFile): Boolean = false
-
-    override fun isUnderSourceRootOfType(p0: VirtualFile, p1: MutableSet<out JpsModuleSourceRootType<*>>): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getOrderEntryForFile(p0: VirtualFile): OrderEntry? {
-        throw UnsupportedOperationException()
-    }
-}
-
-class CoreProjectRootManager(val projectFileIndex: CoreProjectFileIndex) : ProjectRootManager() {
-    override fun orderEntries(): OrderEnumerator {
-        throw UnsupportedOperationException()
-    }
-
-    override fun orderEntries(p0: MutableCollection<out Module>): OrderEnumerator {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootsFromAllModules(): Array<out VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun setProjectSdk(p0: Sdk?) {
-        throw UnsupportedOperationException()
-    }
-
-    override fun setProjectSdkName(p0: String) {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getModuleSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentSourceRoots(): Array<out VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getFileIndex(): ProjectFileIndex = projectFileIndex
-
-    override fun getProjectSdkName(): String? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getProjectSdk(): Sdk? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRoots(): Array<out VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootUrls(): MutableList<String> {
-        throw UnsupportedOperationException()
-    }
-
-}
-
-fun ContentRoot.contains(file: VirtualFile) = when (this) {
-    is JvmContentRoot -> {
-        val path = if (file.fileSystem.protocol == StandardFileSystems.JAR_PROTOCOL)
-            getVirtualFileForJar(file)?.path ?: file.path
-        else
-            file.path
-        File(path).startsWith(this.file.absoluteFile)
-    }
-    is KotlinSourceRoot -> File(file.path).startsWith(File(this.path).absoluteFile)
-    else -> false
-}
diff --git a/core/src/main/kotlin/analysis/JavaResolveExtension.kt b/core/src/main/kotlin/analysis/JavaResolveExtension.kt
deleted file mode 100644
index ab6bec9c..00000000
--- a/core/src/main/kotlin/analysis/JavaResolveExtension.kt
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-@file:JvmName("JavaResolutionUtils")
-
-package org.jetbrains.dokka.analysis
-
-import com.intellij.psi.*
-import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-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.platform.jvm.JvmPlatforms
-import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-
-// TODO: Remove that file
-
-@JvmOverloads
-fun PsiMethod.getJavaMethodDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    val method = originalElement as? PsiMethod ?: return null
-    if (method.containingClass == null || !Name.isValidIdentifier(method.name)) return null
-    val resolver = method.getJavaDescriptorResolver(resolutionFacade)
-    return when {
-        method.isConstructor -> resolver?.resolveConstructor(JavaConstructorImpl(method))
-        else -> resolver?.resolveMethod(JavaMethodImpl(method))
-    }
-}
-
-@JvmOverloads
-fun PsiClass.getJavaClassDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): ClassDescriptor? {
-    val psiClass = originalElement as? PsiClass ?: return null
-    return psiClass.getJavaDescriptorResolver(resolutionFacade)?.resolveClass(JavaClassImpl(psiClass))
-}
-
-@JvmOverloads
-fun PsiField.getJavaFieldDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): PropertyDescriptor? {
-    val field = originalElement as? PsiField ?: return null
-    return field.getJavaDescriptorResolver(resolutionFacade)?.resolveField(JavaFieldImpl(field))
-}
-
-@JvmOverloads
-fun PsiMember.getJavaMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    return when (this) {
-        is PsiEnumConstant -> containingClass?.getJavaClassDescriptor(resolutionFacade)
-        is PsiClass -> getJavaClassDescriptor(resolutionFacade)
-        is PsiMethod -> getJavaMethodDescriptor(resolutionFacade)
-        is PsiField -> getJavaFieldDescriptor(resolutionFacade)
-        else -> null
-    }
-}
-
-@JvmOverloads
-fun PsiMember.getJavaOrKotlinMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    val callable = unwrapped
-    return when (callable) {
-        is PsiMember -> getJavaMemberDescriptor(resolutionFacade)
-        is KtDeclaration -> {
-            val descriptor = resolutionFacade.resolveToDescriptor(callable)
-            if (descriptor is ClassDescriptor && this is PsiMethod) descriptor.unsubstitutedPrimaryConstructor else descriptor
-        }
-        else -> null
-    }
-}
-
-private fun PsiElement.getJavaDescriptorResolver(resolutionFacade: ResolutionFacade): JavaDescriptorResolver? {
-    return resolutionFacade.tryGetFrontendService(this, JavaDescriptorResolver::class.java)
-}
-
-private fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): DeclarationDescriptor? {
-    return getContainingScope(method)
-            ?.getContributedDescriptors(nameFilter = { true }, kindFilter = DescriptorKindFilter.CALLABLES)
-            ?.filterIsInstance<DeclarationDescriptorWithSource>()
-            ?.findByJavaElement(method)
-}
-
-private fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructor): ConstructorDescriptor? {
-    return resolveClass(constructor.containingClass)?.constructors?.findByJavaElement(constructor)
-}
-
-private fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescriptor? {
-    return getContainingScope(field)?.getContributedVariables(field.name, NoLookupLocation.FROM_IDE)?.findByJavaElement(field)
-}
-
-private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): MemberScope? {
-    val containingClass = resolveClass(member.containingClass)
-    return if (member.isStatic)
-        containingClass?.staticScope
-    else
-        containingClass?.defaultType?.memberScope
-}
-
-private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {
-    return firstOrNull { member ->
-        val memberJavaElement = (member.original.source as? JavaSourceElement)?.javaElement
-        when {
-            memberJavaElement == javaElement ->
-                true
-            memberJavaElement is JavaElementImpl<*> && javaElement is JavaElementImpl<*> ->
-                memberJavaElement.psi.isEquivalentTo(javaElement.psi)
-            else ->
-                false
-        }
-    }
-}
-
-fun PsiElement.javaResolutionFacade() =
-    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatforms.defaultJvmPlatform)!!
diff --git a/core/src/main/kotlin/links/DRI.kt b/core/src/main/kotlin/links/DRI.kt
index 9cc51fb7..3f6d886f 100644
--- a/core/src/main/kotlin/links/DRI.kt
+++ b/core/src/main/kotlin/links/DRI.kt
@@ -1,15 +1,5 @@
 package org.jetbrains.dokka.links
 
-import com.intellij.psi.*
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf
-import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.TypeProjection
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-
 /**
  * [DRI] stands for DokkaResourceIdentifier
  */
@@ -21,33 +11,10 @@ data class DRI(
     val extra: String? = null
 ) {
     override fun toString(): String =
-        "${packageName.orEmpty()}/${classNames.orEmpty()}/${callable?.name.orEmpty()}/${callable?.signature().orEmpty()}/$target/${extra.orEmpty()}"
+        "${packageName.orEmpty()}/${classNames.orEmpty()}/${callable?.name.orEmpty()}/${callable?.signature()
+            .orEmpty()}/$target/${extra.orEmpty()}"
 
     companion object {
-        fun from(descriptor: DeclarationDescriptor) = descriptor.parentsWithSelf.run {
-            val callable = firstIsInstanceOrNull<CallableDescriptor>()
-            DRI(
-                firstIsInstanceOrNull<PackageFragmentDescriptor>()?.fqName?.asString(),
-                (filterIsInstance<ClassDescriptor>() + filterIsInstance<TypeAliasDescriptor>()).toList()
-                    .takeIf { it.isNotEmpty() }
-                    ?.asReversed()
-                    ?.joinToString(separator = ".") { it.name.asString() },
-                callable?.let { Callable.from(it) },
-                DriTarget.from(descriptor)
-            )
-        }
-
-        fun from(psi: PsiElement) = psi.parentsWithSelf.run {
-            val psiMethod = firstIsInstanceOrNull<PsiMethod>()
-            val psiField = firstIsInstanceOrNull<PsiField>()
-            val classes = filterIsInstance<PsiClass>().toList()
-            DRI(
-                classes.lastOrNull()?.qualifiedName?.substringBeforeLast('.', ""),
-                classes.toList().takeIf { it.isNotEmpty() }?.asReversed()?.mapNotNull { it.name }?.joinToString("."),
-                psiMethod?.let { Callable.from(it) }  ?: psiField?.let { Callable.from(it) } ,
-                DriTarget.from(psi)
-            )
-        }
         val topLevel = DRI()
     }
 }
@@ -78,71 +45,11 @@ data class Callable(
 ) {
     fun signature() = "${receiver?.toString().orEmpty()}#${params.joinToString("#")}"
 
-    companion object {
-        fun from(descriptor: CallableDescriptor) = with(descriptor) {
-            Callable(
-                name.asString(),
-                extensionReceiverParameter?.let { TypeReference.from(it) },
-                valueParameters.mapNotNull { TypeReference.from(it) }
-            )
-        }
-
-        fun from(psi: PsiMethod) = with(psi) {
-            Callable(
-                name,
-                null,
-                parameterList.parameters.map { param -> JavaClassReference(param.type.canonicalText) })
-        }
-
-        fun from(psi: PsiField): Callable {
-            return Callable(
-                name = psi.name,
-                receiver = null,
-                params = emptyList()
-            )
-        }
-    }
+    companion object
 }
 
 sealed class TypeReference {
-    companion object {
-        fun from(d: ReceiverParameterDescriptor): TypeReference? =
-            when (d.value) {
-                is ExtensionReceiver -> fromPossiblyNullable(d.type)
-                else -> run {
-                    println("Unknown value type for $d")
-                    null
-                }
-            }
-
-        fun from(d: ValueParameterDescriptor): TypeReference? =
-            fromPossiblyNullable(d.type)
-
-        fun from(p: PsiClass) = TypeReference
-
-        private fun fromPossiblyNullable(t: KotlinType, self: KotlinType? = null): TypeReference =
-            from(t, self).let { if (t.isMarkedNullable) Nullable(it) else it }
-
-        private fun from(t: KotlinType, self: KotlinType? = null): TypeReference =
-            if (self is KotlinType && self.constructor == t.constructor && self.arguments == t.arguments)
-                SelfType
-            else when (val d = t.constructor.declarationDescriptor) {
-                is TypeParameterDescriptor -> TypeParam(
-                    d.upperBounds.map { fromPossiblyNullable(it, self ?: t) }
-                )
-                else -> TypeConstructor(
-                    t.constructorName.orEmpty(),
-                    t.arguments.map { fromProjection(it, self) }
-                )
-            }
-
-        private fun fromProjection(t: TypeProjection, r: KotlinType? = null): TypeReference =
-            if (t.isStarProjection) {
-                StarProjection
-            } else {
-                fromPossiblyNullable(t.type, r)
-            }
-    }
+    companion object
 }
 
 data class JavaClassReference(val name: String) : TypeReference() {
@@ -171,39 +78,10 @@ object StarProjection : TypeReference() {
     override fun toString() = "*"
 }
 
-private val KotlinType.constructorName
-    get() = constructor.declarationDescriptor?.fqNameSafe?.asString()
-
 sealed class DriTarget {
     override fun toString(): String = this.javaClass.simpleName
 
-    companion object {
-        fun from(descriptor: DeclarationDescriptor): DriTarget = descriptor.parentsWithSelf.run {
-            return when (descriptor) {
-                is TypeParameterDescriptor -> PointingToGenericParameters(descriptor.index)
-                else -> {
-                    val callable = firstIsInstanceOrNull<CallableDescriptor>()
-                    val params =
-                        callable?.let { listOfNotNull(it.extensionReceiverParameter) + it.valueParameters }.orEmpty()
-                    val parameterDescriptor = firstIsInstanceOrNull<ParameterDescriptor>()
-
-                    parameterDescriptor?.let { PointingToCallableParameters(params.indexOf(it)) }
-                        ?: PointingToDeclaration
-                }
-            }
-        }
-
-        fun from(psi: PsiElement): DriTarget = psi.parentsWithSelf.run {
-            return when (psi) {
-                is PsiTypeParameter -> PointingToGenericParameters(psi.index)
-                else -> firstIsInstanceOrNull<PsiParameter>()?.let {
-                    val callable = firstIsInstanceOrNull<PsiMethod>()
-                    val params = (callable?.parameterList?.parameters).orEmpty()
-                    PointingToCallableParameters(params.indexOf(it))
-                } ?: PointingToDeclaration
-            }
-        }
-    }
+    companion object
 }
 
 data class PointingToGenericParameters(val parameterIndex: Int) : DriTarget() {
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index 90958210..768bddc5 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -1,12 +1,10 @@
 package org.jetbrains.dokka.model
 
-import com.intellij.psi.PsiNamedElement
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.model.properties.WithExtraProperties
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.load.kotlin.toSourceElement
+
 
 abstract class Documentable {
     abstract val name: String?
@@ -406,11 +404,3 @@ fun <T> SourceSetDependent<T>?.orEmpty(): SourceSetDependent<T> = this ?: emptyM
 interface DocumentableSource {
     val path: String
 }
-
-class DescriptorDocumentableSource(val descriptor: DeclarationDescriptor) : DocumentableSource {
-    override val path = descriptor.toSourceElement.containingFile.toString()
-}
-
-class PsiDocumentableSource(val psi: PsiNamedElement) : DocumentableSource {
-    override val path = psi.containingFile.virtualFile.path
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/properties/PropertyContainer.kt b/core/src/main/kotlin/model/properties/PropertyContainer.kt
index 107bede5..e1e0250e 100644
--- a/core/src/main/kotlin/model/properties/PropertyContainer.kt
+++ b/core/src/main/kotlin/model/properties/PropertyContainer.kt
@@ -1,7 +1,5 @@
 package org.jetbrains.dokka.model.properties
 
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-
 class PropertyContainer<C : Any> internal constructor(
     @PublishedApi internal val map: Map<ExtraProperty.Key<C, *>, ExtraProperty<C>>
 ) {
@@ -45,7 +43,7 @@ fun <C> C.mergeExtras(left: C, right: C): C where C : Any, C : WithExtraProperti
         (l.key as ExtraProperty.Key<C, ExtraProperty<C>>).mergeStrategyFor(l, r)
     }
 
-    strategies.firstIsInstanceOrNull<MergeStrategy.Fail>()?.error?.invoke()
+    strategies.filterIsInstance<MergeStrategy.Fail>().firstOrNull()?.error?.invoke()
 
     val replaces: List<ExtraProperty<C>> =
         strategies.filterIsInstance<MergeStrategy.Replace<C>>().map { it.newProperty }
diff --git a/core/src/main/kotlin/parsers/HtmlParser.kt b/core/src/main/kotlin/parsers/HtmlParser.kt
deleted file mode 100644
index a0652b95..00000000
--- a/core/src/main/kotlin/parsers/HtmlParser.kt
+++ /dev/null
@@ -1,89 +0,0 @@
-package org.jetbrains.dokka.parsers
-
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.parsers.factories.DocTagsFromStringFactory
-import org.jsoup.Jsoup
-import org.jsoup.nodes.Node
-import org.jsoup.select.NodeFilter
-import org.jsoup.select.NodeTraversor
-
-class HtmlParser : Parser() {
-
-    inner class NodeFilterImpl : NodeFilter {
-
-        private val nodesCache: MutableMap<Int, MutableList<DocTag>> = mutableMapOf()
-        private var currentDepth = 0
-
-        fun collect(): DocTag = nodesCache[currentDepth]!![0]
-
-        override fun tail(node: Node?, depth: Int): NodeFilter.FilterResult {
-            val nodeName = node!!.nodeName()
-            val nodeAttributes = node.attributes()
-
-            if(nodeName in listOf("#document", "html", "head"))
-                return NodeFilter.FilterResult.CONTINUE
-
-            val body: String
-            val params: Map<String, String>
-
-
-            if(nodeName != "#text") {
-                body = ""
-                params = nodeAttributes.map { it.key to it.value }.toMap()
-            } else {
-                body = nodeAttributes["#text"]
-                params = emptyMap()
-            }
-
-            val docNode = if(depth < currentDepth) {
-                DocTagsFromStringFactory.getInstance(nodeName, nodesCache.getOrDefault(currentDepth, mutableListOf()).toList(), params, body).also {
-                    nodesCache[currentDepth] = mutableListOf()
-                    currentDepth = depth
-                }
-            } else {
-                DocTagsFromStringFactory.getInstance(nodeName, emptyList(), params, body)
-            }
-
-            nodesCache.getOrDefault(depth, mutableListOf()) += docNode
-            return NodeFilter.FilterResult.CONTINUE
-        }
-
-        override fun head(node: Node?, depth: Int): NodeFilter.FilterResult {
-
-            val nodeName = node!!.nodeName()
-
-            if(currentDepth < depth) {
-                currentDepth = depth
-                nodesCache[currentDepth] = mutableListOf()
-            }
-
-            if(nodeName in listOf("#document", "html", "head"))
-                return NodeFilter.FilterResult.CONTINUE
-
-            return NodeFilter.FilterResult.CONTINUE
-        }
-    }
-
-
-    private fun htmlToDocNode(string: String): DocTag {
-        val document = Jsoup.parse(string)
-        val nodeFilterImpl = NodeFilterImpl()
-        NodeTraversor.filter(nodeFilterImpl, document.root())
-        return nodeFilterImpl.collect()
-    }
-
-    private fun replaceLinksWithHrefs(javadoc: String): String = Regex("\\{@link .*?}").replace(javadoc) {
-        val split = it.value.dropLast(1).split(" ")
-        if(split.size !in listOf(2, 3))
-            return@replace it.value
-        if(split.size == 3)
-            return@replace "<documentationlink href=\"${split[1]}\">${split[2]}</documentationlink>"
-        else
-            return@replace "<documentationlink href=\"${split[1]}\">${split[1]}</documentationlink>"
-    }
-
-    override fun parseStringToDocNode(extractedString: String) = htmlToDocNode(extractedString)
-    override fun preparse(text: String) = replaceLinksWithHrefs(text)
-}
-
-
diff --git a/core/src/main/kotlin/parsers/MarkdownParser.kt b/core/src/main/kotlin/parsers/MarkdownParser.kt
deleted file mode 100644
index 07e1fcc3..00000000
--- a/core/src/main/kotlin/parsers/MarkdownParser.kt
+++ /dev/null
@@ -1,418 +0,0 @@
-package org.jetbrains.dokka.parsers
-
-import com.intellij.psi.PsiElement
-import org.jetbrains.dokka.model.doc.*
-import org.intellij.markdown.MarkdownElementTypes
-import org.intellij.markdown.MarkdownTokenTypes
-import org.intellij.markdown.ast.ASTNode
-import org.intellij.markdown.ast.CompositeASTNode
-import org.intellij.markdown.ast.LeafASTNode
-import org.intellij.markdown.ast.impl.ListItemCompositeNode
-import org.intellij.markdown.flavours.gfm.GFMElementTypes
-import org.intellij.markdown.flavours.gfm.GFMFlavourDescriptor
-import org.intellij.markdown.flavours.gfm.GFMTokenTypes
-import org.jetbrains.dokka.analysis.DokkaResolutionFacade
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.parsers.factories.DocTagsFromIElementFactory
-import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
-import org.jetbrains.kotlin.kdoc.parser.KDocKnownTag
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocSection
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
-import java.net.MalformedURLException
-import org.intellij.markdown.parser.MarkdownParser as IntellijMarkdownParser
-
-class MarkdownParser(
-    private val resolutionFacade: DokkaResolutionFacade? = null,
-    private val declarationDescriptor: DeclarationDescriptor? = null,
-    private val logger: DokkaLogger
-) : Parser() {
-
-    inner class MarkdownVisitor(val text: String, val destinationLinksMap: Map<String, String>) {
-
-        private fun headersHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type,
-                visitNode(node.children.find { it.type == MarkdownTokenTypes.ATX_CONTENT }
-                    ?: throw IllegalStateException("Wrong AST Tree. ATX Header does not contain expected content")).children
-            )
-
-        private fun horizontalRulesHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(MarkdownTokenTypes.HORIZONTAL_RULE)
-
-        private fun emphasisHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type,
-                children = listOf(visitNode(node.children[node.children.size / 2]))
-            )
-
-        private fun blockquotesHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type, children = node.children
-                    .filterIsInstance<CompositeASTNode>()
-                    .evaluateChildren()
-            )
-
-        private fun listsHandler(node: ASTNode): DocTag {
-
-            val children = node.children.filterIsInstance<ListItemCompositeNode>().flatMap {
-                if (it.children.last().type in listOf(
-                        MarkdownElementTypes.ORDERED_LIST,
-                        MarkdownElementTypes.UNORDERED_LIST
-                    )
-                ) {
-                    val nestedList = it.children.last()
-                    (it.children as MutableList).removeAt(it.children.lastIndex)
-                    listOf(it, nestedList)
-                } else
-                    listOf(it)
-            }
-
-            return DocTagsFromIElementFactory.getInstance(
-                node.type,
-                children =
-                children
-                    .map {
-                        if (it.type == MarkdownElementTypes.LIST_ITEM)
-                            DocTagsFromIElementFactory.getInstance(
-                                it.type,
-                                children = it
-                                    .children
-                                    .filterIsInstance<CompositeASTNode>()
-                                    .evaluateChildren()
-                            )
-                        else
-                            visitNode(it)
-                    },
-                params =
-                if (node.type == MarkdownElementTypes.ORDERED_LIST) {
-                    val listNumberNode = node.children.first().children.first()
-                    mapOf(
-                        "start" to text.substring(
-                            listNumberNode.startOffset,
-                            listNumberNode.endOffset
-                        ).trim().dropLast(1)
-                    )
-                } else
-                    emptyMap()
-            )
-        }
-
-        private fun resolveDRI(mdLink: String): DRI? =
-            mdLink
-                .removePrefix("[")
-                .removeSuffix("]")
-                .let { link ->
-                    try {
-                        java.net.URL(link)
-                        null
-                    } catch (e: MalformedURLException) {
-                        try {
-                            if (resolutionFacade != null && declarationDescriptor != null) {
-                                resolveKDocLink(
-                                    resolutionFacade.resolveSession.bindingContext,
-                                    resolutionFacade,
-                                    declarationDescriptor,
-                                    null,
-                                    link.split('.')
-                                ).minBy { it is ClassDescriptor }?.let { DRI.from(it) }
-                            } else null
-                        } catch (e1: IllegalArgumentException) {
-                            null
-                        }
-                    }
-                }
-
-        private fun referenceLinksHandler(node: ASTNode): DocTag {
-            val linkLabel = node.children.find { it.type == MarkdownElementTypes.LINK_LABEL }
-                ?: throw IllegalStateException("Wrong AST Tree. Reference link does not contain expected content")
-            val linkText = node.children.findLast { it.type == MarkdownElementTypes.LINK_TEXT } ?: linkLabel
-
-            val linkKey = text.substring(linkLabel.startOffset, linkLabel.endOffset)
-
-            val link = destinationLinksMap[linkKey.toLowerCase()] ?: linkKey
-
-            return linksHandler(linkText, link)
-        }
-
-        private fun inlineLinksHandler(node: ASTNode): DocTag {
-            val linkText = node.children.find { it.type == MarkdownElementTypes.LINK_TEXT }
-                ?: throw IllegalStateException("Wrong AST Tree. Inline link does not contain expected content")
-            val linkDestination = node.children.find { it.type == MarkdownElementTypes.LINK_DESTINATION }
-                ?: throw IllegalStateException("Wrong AST Tree. Inline link does not contain expected content")
-            val linkTitle = node.children.find { it.type == MarkdownElementTypes.LINK_TITLE }
-
-            val link = text.substring(linkDestination.startOffset, linkDestination.endOffset)
-
-            return linksHandler(linkText, link, linkTitle)
-        }
-
-        private fun autoLinksHandler(node: ASTNode): DocTag {
-            val link = text.substring(node.startOffset + 1, node.endOffset - 1)
-
-            return linksHandler(node, link)
-        }
-
-        private fun linksHandler(linkText: ASTNode, link: String, linkTitle: ASTNode? = null): DocTag {
-            val dri: DRI? = resolveDRI(link)
-            val params = if (linkTitle == null)
-                mapOf("href" to link)
-            else
-                mapOf("href" to link, "title" to text.substring(linkTitle.startOffset + 1, linkTitle.endOffset - 1))
-
-            return DocTagsFromIElementFactory.getInstance(
-                MarkdownElementTypes.INLINE_LINK,
-                params = params,
-                children = linkText.children.drop(1).dropLast(1).evaluateChildren(),
-                dri = dri
-            )
-        }
-
-        private fun imagesHandler(node: ASTNode): DocTag {
-            val linkNode =
-                node.children.last().children.find { it.type == MarkdownElementTypes.LINK_LABEL }!!.children[1]
-            val link = text.substring(linkNode.startOffset, linkNode.endOffset)
-            val src = mapOf("src" to link)
-            return DocTagsFromIElementFactory.getInstance(
-                node.type,
-                params = src,
-                children = listOf(visitNode(node.children.last().children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!))
-            )
-        }
-
-        private fun codeSpansHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type,
-                children = listOf(
-                    DocTagsFromIElementFactory.getInstance(
-                        MarkdownTokenTypes.TEXT,
-                        body = text.substring(node.startOffset + 1, node.endOffset - 1).replace('\n', ' ').trimIndent()
-                    )
-
-                )
-            )
-
-        private fun codeFencesHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type,
-                children = node
-                    .children
-                    .dropWhile { it.type != MarkdownTokenTypes.CODE_FENCE_CONTENT }
-                    .dropLastWhile { it.type != MarkdownTokenTypes.CODE_FENCE_CONTENT }
-                    .map {
-                        if (it.type == MarkdownTokenTypes.EOL)
-                            LeafASTNode(MarkdownTokenTypes.HARD_LINE_BREAK, 0, 0)
-                        else
-                            it
-                    }.evaluateChildren(),
-                params = node
-                    .children
-                    .find { it.type == MarkdownTokenTypes.FENCE_LANG }
-                    ?.let { mapOf("lang" to text.substring(it.startOffset, it.endOffset)) }
-                    ?: emptyMap()
-            )
-
-        private fun codeBlocksHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(node.type, children = node.children.evaluateChildren())
-
-        private fun defaultHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                MarkdownElementTypes.PARAGRAPH,
-                children = node.children.evaluateChildren()
-            )
-
-        fun visitNode(node: ASTNode): DocTag =
-            when (node.type) {
-                MarkdownElementTypes.ATX_1,
-                MarkdownElementTypes.ATX_2,
-                MarkdownElementTypes.ATX_3,
-                MarkdownElementTypes.ATX_4,
-                MarkdownElementTypes.ATX_5,
-                MarkdownElementTypes.ATX_6 -> headersHandler(node)
-                MarkdownTokenTypes.HORIZONTAL_RULE -> horizontalRulesHandler(node)
-                MarkdownElementTypes.STRONG,
-                MarkdownElementTypes.EMPH -> emphasisHandler(node)
-                MarkdownElementTypes.FULL_REFERENCE_LINK,
-                MarkdownElementTypes.SHORT_REFERENCE_LINK -> referenceLinksHandler(node)
-                MarkdownElementTypes.INLINE_LINK -> inlineLinksHandler(node)
-                MarkdownElementTypes.AUTOLINK -> autoLinksHandler(node)
-                MarkdownElementTypes.BLOCK_QUOTE -> blockquotesHandler(node)
-                MarkdownElementTypes.UNORDERED_LIST,
-                MarkdownElementTypes.ORDERED_LIST -> listsHandler(node)
-                MarkdownElementTypes.CODE_BLOCK -> codeBlocksHandler(node)
-                MarkdownElementTypes.CODE_FENCE -> codeFencesHandler(node)
-                MarkdownElementTypes.CODE_SPAN -> codeSpansHandler(node)
-                MarkdownElementTypes.IMAGE -> imagesHandler(node)
-                MarkdownTokenTypes.HARD_LINE_BREAK -> DocTagsFromIElementFactory.getInstance(node.type)
-                MarkdownTokenTypes.CODE_FENCE_CONTENT,
-                MarkdownTokenTypes.CODE_LINE,
-                MarkdownTokenTypes.TEXT -> DocTagsFromIElementFactory.getInstance(
-                    MarkdownTokenTypes.TEXT,
-                    body = text
-                        .substring(node.startOffset, node.endOffset).transform()
-                )
-                MarkdownElementTypes.MARKDOWN_FILE -> if (node.children.size == 1) visitNode(node.children.first()) else defaultHandler(
-                    node
-                )
-                GFMElementTypes.STRIKETHROUGH -> DocTagsFromIElementFactory.getInstance(
-                    GFMElementTypes.STRIKETHROUGH,
-                    body = text
-                        .substring(node.startOffset, node.endOffset).transform()
-                )
-                GFMElementTypes.TABLE -> DocTagsFromIElementFactory.getInstance(
-                    GFMElementTypes.TABLE,
-                    children = node.children.filterTabSeparators().evaluateChildren()
-                )
-                GFMElementTypes.HEADER -> DocTagsFromIElementFactory.getInstance(
-                    GFMElementTypes.HEADER,
-                    children = node.children.filterTabSeparators().evaluateChildren()
-                )
-                GFMElementTypes.ROW -> DocTagsFromIElementFactory.getInstance(
-                    GFMElementTypes.ROW,
-                    children = node.children.filterTabSeparators().evaluateChildren()
-                )
-                else -> defaultHandler(node)
-            }
-
-        private fun List<ASTNode>.filterTabSeparators() =
-            this.filterNot { it.type == GFMTokenTypes.TABLE_SEPARATOR }
-
-        private fun List<ASTNode>.evaluateChildren(): List<DocTag> =
-            this.removeUselessTokens().mergeLeafASTNodes().map { visitNode(it) }
-
-        private fun List<ASTNode>.removeUselessTokens(): List<ASTNode> =
-            this.filterIndexed { index, node ->
-                !(node.type == MarkdownElementTypes.LINK_DEFINITION || (
-                        node.type == MarkdownTokenTypes.EOL &&
-                                this.getOrNull(index - 1)?.type == MarkdownTokenTypes.HARD_LINE_BREAK
-                        ))
-            }
-
-        private val notLeafNodes = listOf(MarkdownTokenTypes.HORIZONTAL_RULE, MarkdownTokenTypes.HARD_LINE_BREAK)
-
-        private fun List<ASTNode>.isNotLeaf(index: Int): Boolean =
-            if (index in 0..this.lastIndex)
-                (this[index] is CompositeASTNode) || this[index].type in notLeafNodes
-            else
-                false
-
-        private fun List<ASTNode>.mergeLeafASTNodes(): List<ASTNode> {
-            val children: MutableList<ASTNode> = mutableListOf()
-            var index = 0
-            while (index <= this.lastIndex) {
-                if (this.isNotLeaf(index)) {
-                    children += this[index]
-                } else {
-                    val startOffset = this[index].startOffset
-                    while (index < this.lastIndex) {
-                        if (this.isNotLeaf(index + 1) || this[index + 1].startOffset != this[index].endOffset) {
-                            val endOffset = this[index].endOffset
-                            if (text.substring(startOffset, endOffset).transform().trim().isNotEmpty())
-                                children += LeafASTNode(MarkdownTokenTypes.TEXT, startOffset, endOffset)
-                            break
-                        }
-                        index++
-                    }
-                    if (index == this.lastIndex) {
-                        val endOffset = this[index].endOffset
-                        if (text.substring(startOffset, endOffset).transform().trim().isNotEmpty())
-                            children += LeafASTNode(MarkdownTokenTypes.TEXT, startOffset, endOffset)
-                    }
-                }
-                index++
-            }
-            return children
-        }
-
-        private fun String.transform() = this
-            .replace(Regex("\n\n+"), "")        // Squashing new lines between paragraphs
-            .replace(Regex("\n"), " ")
-            .replace(Regex(" >+ +"), " ")      // Replacement used in blockquotes, get rid of garbage
-    }
-
-
-    private fun getAllDestinationLinks(text: String, node: ASTNode): List<Pair<String, String>> =
-        node.children
-            .filter { it.type == MarkdownElementTypes.LINK_DEFINITION }
-            .map {
-                text.substring(it.children[0].startOffset, it.children[0].endOffset).toLowerCase() to
-                        text.substring(it.children[2].startOffset, it.children[2].endOffset)
-            } +
-                node.children.filterIsInstance<CompositeASTNode>().flatMap { getAllDestinationLinks(text, it) }
-
-
-    private fun markdownToDocNode(text: String): DocTag {
-
-        val flavourDescriptor = GFMFlavourDescriptor()
-        val markdownAstRoot: ASTNode = IntellijMarkdownParser(flavourDescriptor).buildMarkdownTreeFromString(text)
-
-        return MarkdownVisitor(text, getAllDestinationLinks(text, markdownAstRoot).toMap()).visitNode(markdownAstRoot)
-    }
-
-    override fun parseStringToDocNode(extractedString: String) = markdownToDocNode(extractedString)
-    override fun preparse(text: String) = text
-
-    private fun findParent(kDoc: PsiElement): PsiElement =
-        if (kDoc is KDocSection) findParent(kDoc.parent) else kDoc
-
-    private fun getAllKDocTags(kDocImpl: PsiElement): List<KDocTag> =
-        kDocImpl.children.filterIsInstance<KDocTag>().filterNot { it is KDocSection } + kDocImpl.children.flatMap {
-            getAllKDocTags(
-                it
-            )
-        }
-
-    fun parseFromKDocTag(kDocTag: KDocTag?): DocumentationNode {
-        return if (kDocTag == null)
-            DocumentationNode(emptyList())
-        else
-            DocumentationNode(
-                (listOf(kDocTag) + getAllKDocTags(findParent(kDocTag))).map {
-                    when (it.knownTag) {
-                        null -> if (it.name == null) Description(parseStringToDocNode(it.getContent())) else CustomTagWrapper(
-                            parseStringToDocNode(it.getContent()),
-                            it.name!!
-                        )
-                        KDocKnownTag.AUTHOR -> Author(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.THROWS -> Throws(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.EXCEPTION -> Throws(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.PARAM -> Param(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.RECEIVER -> Receiver(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.RETURN -> Return(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.SEE -> See(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty(),
-                            parseStringToDocNode("[${it.getSubjectName()}]")
-                                .let {
-                                    val link = it.children[0]
-                                    if (link is DocumentationLink) link.dri
-                                    else null
-                                }
-                        )
-                        KDocKnownTag.SINCE -> Since(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.CONSTRUCTOR -> Constructor(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.PROPERTY -> Property(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.SAMPLE -> Sample(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.SUPPRESS -> Suppress(parseStringToDocNode(it.getContent()))
-                    }
-                }
-            )
-    }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/Parser.kt b/core/src/main/kotlin/parsers/Parser.kt
deleted file mode 100644
index 05adc4d5..00000000
--- a/core/src/main/kotlin/parsers/Parser.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.jetbrains.dokka.parsers
-
-import org.jetbrains.dokka.model.doc.*
-
-abstract class Parser {
-
-    abstract fun parseStringToDocNode(extractedString: String): DocTag
-    abstract fun preparse(text: String): String
-
-    fun parse(text: String): DocumentationNode {
-
-        val list = jkdocToListOfPairs(preparse(text))
-
-        val mappedList: List<TagWrapper> = list.map {
-            when(it.first) {
-                "description"         -> Description(parseStringToDocNode(it.second))
-                "author"              -> Author(parseStringToDocNode(it.second))
-                "version"             -> Version(parseStringToDocNode(it.second))
-                "since"               -> Since(parseStringToDocNode(it.second))
-                "see"                 -> See(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '), null)
-                "param"               -> Param(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
-                "property"            -> Property(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
-                "return"              -> Return(parseStringToDocNode(it.second))
-                "constructor"         -> Constructor(parseStringToDocNode(it.second))
-                "receiver"            -> Receiver(parseStringToDocNode(it.second))
-                "throws", "exception" -> Throws(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
-                "deprecated"          -> Deprecated(parseStringToDocNode(it.second))
-                "sample"              -> Sample(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
-                "suppress"            -> Suppress(parseStringToDocNode(it.second))
-                else                  -> CustomTagWrapper(parseStringToDocNode(it.second), it.first)
-            }
-        }
-        return DocumentationNode(mappedList)
-    }
-
-    private fun jkdocToListOfPairs(javadoc: String): List<Pair<String, String>> =
-        "description $javadoc"
-            .split("\n@")
-            .map {
-                it.substringBefore(' ') to it.substringAfter(' ')
-            }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt b/core/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
deleted file mode 100644
index dda6c627..00000000
--- a/core/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
+++ /dev/null
@@ -1,43 +0,0 @@
-package org.jetbrains.dokka.parsers.factories
-
-import org.jetbrains.dokka.model.doc.*
-import org.intellij.markdown.IElementType
-import org.intellij.markdown.MarkdownElementTypes
-import org.intellij.markdown.MarkdownTokenTypes
-import org.intellij.markdown.flavours.gfm.GFMElementTypes
-import org.jetbrains.dokka.links.DRI
-import java.lang.NullPointerException
-
-object DocTagsFromIElementFactory {
-    fun getInstance(type: IElementType, children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
-        when(type) {
-            MarkdownElementTypes.SHORT_REFERENCE_LINK,
-            MarkdownElementTypes.FULL_REFERENCE_LINK,
-            MarkdownElementTypes.INLINE_LINK            -> if(dri == null) A(children, params) else DocumentationLink(dri, children, params)
-            MarkdownElementTypes.STRONG                 -> B(children, params)
-            MarkdownElementTypes.BLOCK_QUOTE            -> BlockQuote(children, params)
-            MarkdownElementTypes.CODE_SPAN,
-            MarkdownElementTypes.CODE_BLOCK,
-            MarkdownElementTypes.CODE_FENCE             -> Code(children, params)
-            MarkdownElementTypes.ATX_1                  -> H1(children, params)
-            MarkdownElementTypes.ATX_2                  -> H2(children, params)
-            MarkdownElementTypes.ATX_3                  -> H3(children, params)
-            MarkdownElementTypes.ATX_4                  -> H4(children, params)
-            MarkdownElementTypes.ATX_5                  -> H5(children, params)
-            MarkdownElementTypes.ATX_6                  -> H6(children, params)
-            MarkdownElementTypes.EMPH                   -> I(children, params)
-            MarkdownElementTypes.IMAGE                  -> Img(children, params)
-            MarkdownElementTypes.LIST_ITEM              -> Li(children, params)
-            MarkdownElementTypes.ORDERED_LIST           -> Ol(children, params)
-            MarkdownElementTypes.UNORDERED_LIST         -> Ul(children, params)
-            MarkdownElementTypes.PARAGRAPH              -> P(children, params)
-            MarkdownTokenTypes.TEXT                     -> Text(body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"), children, params )
-            MarkdownTokenTypes.HORIZONTAL_RULE          -> HorizontalRule
-            MarkdownTokenTypes.HARD_LINE_BREAK          -> Br
-            GFMElementTypes.STRIKETHROUGH               -> Strikethrough(children, params)
-            GFMElementTypes.TABLE                       -> Table(children, params)
-            GFMElementTypes.HEADER                      -> Th(children, params)
-            GFMElementTypes.ROW                         -> Tr(children, params)
-            else                                        -> CustomDocTag(children, params)
-        }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt b/core/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt
deleted file mode 100644
index 3425f52e..00000000
--- a/core/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt
+++ /dev/null
@@ -1,77 +0,0 @@
-package org.jetbrains.dokka.parsers.factories
-
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.links.DRI
-import java.lang.NullPointerException
-
-object DocTagsFromStringFactory {
-    fun getInstance(name: String, children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
-        when(name) {
-            "a" -> A(children, params)
-            "big" -> Big(children, params)
-            "b" -> B(children, params)
-            "blockquote" -> BlockQuote(children, params)
-            "br" -> Br
-            "cite" -> Cite(children, params)
-            "code" -> Code(children, params)
-            "dd" -> Dd(children, params)
-            "dfn" -> Dfn(children, params)
-            "dir" -> Dir(children, params)
-            "div" -> Div(children, params)
-            "dl" -> Dl(children, params)
-            "dt" -> Dt(children, params)
-            "Em" -> Em(children, params)
-            "font" -> Font(children, params)
-            "footer" -> Footer(children, params)
-            "frame" -> Frame(children, params)
-            "frameset" -> FrameSet(children, params)
-            "h1" -> H1(children, params)
-            "h2" -> H2(children, params)
-            "h3" -> H3(children, params)
-            "h4" -> H4(children, params)
-            "h5" -> H5(children, params)
-            "h6" -> H6(children, params)
-            "head" -> Head(children, params)
-            "header" -> Header(children, params)
-            "html" -> Html(children, params)
-            "i" -> I(children, params)
-            "iframe" -> IFrame(children, params)
-            "img" -> Img(children, params)
-            "input" -> Input(children, params)
-            "li" -> Li(children, params)
-            "link" -> Link(children, params)
-            "listing" -> Listing(children, params)
-            "main" -> Main(children, params)
-            "menu" -> Menu(children, params)
-            "meta" -> Meta(children, params)
-            "nav" -> Nav(children, params)
-            "noframes" -> NoFrames(children, params)
-            "noscript" -> NoScript(children, params)
-            "ol" -> Ol(children, params)
-            "p" -> P(children, params)
-            "pre" -> Pre(children, params)
-            "script" -> Script(children, params)
-            "section" -> Section(children, params)
-            "small" -> Small(children, params)
-            "span" -> Span(children, params)
-            "strong" -> Strong(children, params)
-            "sub" -> Sub(children, params)
-            "sup" -> Sup(children, params)
-            "table" -> Table(children, params)
-            "#text" -> Text(body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"), children, params)
-            "tBody" -> TBody(children, params)
-            "td" -> Td(children, params)
-            "tFoot" -> TFoot(children, params)
-            "th" -> Th(children, params)
-            "tHead" -> THead(children, params)
-            "title" -> Title(children, params)
-            "tr" -> Tr(children, params)
-            "tt" -> Tt(children, params)
-            "u" -> U(children, params)
-            "ul" -> Ul(children, params)
-            "var" -> Var(children, params)
-            "documentationlink" -> DocumentationLink(dri ?: throw NullPointerException("DRI cannot be passed null while constructing documentation link!"), children, params)
-            "hr" -> HorizontalRule
-            else -> CustomDocTag(children, params)
-        }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 692803dd..a2ff26c7 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,9 +1,7 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.utilities.DokkaLogger
 import java.io.File
 import java.net.URLClassLoader
@@ -23,7 +21,6 @@ interface DokkaContext {
     val sourceSetCache: SourceSetCache
     val logger: DokkaLogger
     val configuration: DokkaConfiguration
-    val platforms: Map<SourceSetData, EnvironmentAndFacade>
     val unusedPoints: Collection<ExtensionPoint<*>>
 
 
@@ -31,11 +28,10 @@ interface DokkaContext {
         fun create(
             configuration: DokkaConfiguration,
             logger: DokkaLogger,
-            sourceSets: Map<SourceSetData, EnvironmentAndFacade>,
             sourceSetsCache: SourceSetCache,
             pluginOverrides: List<DokkaPlugin>
         ): DokkaContext =
-            DokkaContextConfigurationImpl(logger, configuration, sourceSets, sourceSetsCache).apply {
+            DokkaContextConfigurationImpl(logger, configuration, sourceSetsCache).apply {
                 // File(it.path) is a workaround for an incorrect filesystem in a File instance returned by Gradle.
                 configuration.pluginsClasspath.map { File(it.path).toURI().toURL() }
                     .toTypedArray()
@@ -59,7 +55,6 @@ interface DokkaContextConfiguration {
 private class DokkaContextConfigurationImpl(
     override val logger: DokkaLogger,
     override val configuration: DokkaConfiguration,
-    override val platforms: Map<SourceSetData, EnvironmentAndFacade>,
     override val sourceSetCache: SourceSetCache
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 24f417d8..fe472b12 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -2,7 +2,6 @@ package org.jetbrains.dokka.plugability
 
 import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.kotlin.utils.addToStdlib.cast
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
@@ -60,8 +59,9 @@ interface ConfigurableBlock
 
 inline fun <reified P : DokkaPlugin, reified T : ConfigurableBlock> Configurable.pluginConfiguration(block: T.() -> Unit) {
     val instance = T::class.createInstance().apply(block)
-    pluginsConfiguration.cast<MutableMap<String, String>>()[P::class.qualifiedName!!] =
-        Gson().toJson(instance, T::class.java)
+
+    val mutablePluginsConfiguration = pluginsConfiguration as MutableMap<String, String>
+    mutablePluginsConfiguration[P::class.qualifiedName!!] = Gson().toJson(instance, T::class.java)
 }
 
 inline fun <reified P : DokkaPlugin, reified E : Any> P.query(extension: P.() -> ExtensionPoint<E>): List<E> =
diff --git a/core/src/main/kotlin/utilities/cast.kt b/core/src/main/kotlin/utilities/cast.kt
new file mode 100644
index 00000000..d4a8d73d
--- /dev/null
+++ b/core/src/main/kotlin/utilities/cast.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.dokka.utilities
+
+inline fun <reified T> Any.cast(): T {
+    return this as T
+}
diff --git a/coreDependencies/build.gradle.kts b/coreDependencies/build.gradle.kts
deleted file mode 100644
index 9af82d9f..00000000
--- a/coreDependencies/build.gradle.kts
+++ /dev/null
@@ -1,65 +0,0 @@
-import org.jetbrains.configureBintrayPublication
-
-plugins {
-    id("com.github.johnrengelman.shadow")
-    `maven-publish`
-    id("com.jfrog.bintray")
-}
-
-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
-    }
-    implementation("org.jetbrains:markdown:0.1.41") {
-        because("it's published only on bintray")
-    }
-    implementation("org.jetbrains.kotlin:ide-common-ij193:$kotlin_plugin_version")
-    implementation(kotlin("stdlib-jdk8"))
-    implementation(kotlin("reflect"))
-}
-
-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/**")
-        exclude("**/*.kotlin_metadata")
-        exclude("**/*.kotlin_builtins")
-    }
-}
-
-publishing {
-    publications {
-        register<MavenPublication>("dokkaCoreDependencies") {
-            artifactId = "dokka-core-dependencies"
-            project.shadow.component(this)
-        }
-    }
-}
-
-configureBintrayPublication("dokkaCoreDependencies")
diff --git a/integration-tests/gradle-integration-tests/build.gradle.kts b/integration-tests/gradle-integration-tests/build.gradle.kts
index 7fc945b5..7cb96738 100644
--- a/integration-tests/gradle-integration-tests/build.gradle.kts
+++ b/integration-tests/gradle-integration-tests/build.gradle.kts
@@ -14,7 +14,7 @@ dependencies {
     testImplementation(gradleTestKit())
 
     dokkaPlugin(project(path = ":runners:gradle-plugin"))
-    dokkaCore(project(path = ":coreDependencies", configuration = "shadow"))
+    dokkaCore(project(path = ":core:dependencies", configuration = "shadow"))
     dokkaCore(project(path = ":core"))
     kotlinGradle("org.jetbrains.kotlin:kotlin-gradle-plugin")
 }
diff --git a/kotlin-analysis/build.gradle.kts b/kotlin-analysis/build.gradle.kts
new file mode 100644
index 00000000..67480f82
--- /dev/null
+++ b/kotlin-analysis/build.gradle.kts
@@ -0,0 +1,27 @@
+import org.jetbrains.configureBintrayPublication
+
+plugins {
+    id("com.github.johnrengelman.shadow")
+    `maven-publish`
+    id("com.jfrog.bintray")
+}
+
+dependencies {
+    compileOnly(project(":core"))
+
+    val kotlin_version: String by project
+    api("org.jetbrains.kotlin:kotlin-compiler:$kotlin_version")
+
+    api(project(":kotlin-analysis:dependencies", configuration = "shadow"))
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("analysis") {
+            artifactId = "dokka-analysis"
+            from(components["java"])
+        }
+    }
+}
+
+configureBintrayPublication("analysis")
diff --git a/kotlin-analysis/dependencies/build.gradle.kts b/kotlin-analysis/dependencies/build.gradle.kts
new file mode 100644
index 00000000..5bba6422
--- /dev/null
+++ b/kotlin-analysis/dependencies/build.gradle.kts
@@ -0,0 +1,67 @@
+import org.jetbrains.configureBintrayPublication
+
+
+plugins {
+    id("com.github.johnrengelman.shadow")
+    `maven-publish`
+    id("com.jfrog.bintray")
+}
+
+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")
+}
+
+val intellijCore: Configuration by configurations.creating
+
+fun intellijCoreAnalysis() = zipTree(intellijCore.singleFile).matching {
+    include("intellij-core-analysis.jar")
+}
+
+dependencies {
+    val kotlin_plugin_version: String by project
+    api("org.jetbrains.kotlin:ide-common-ij193:$kotlin_plugin_version")
+    api("org.jetbrains.kotlin:kotlin-plugin-ij193:$kotlin_plugin_version") {
+        //TODO: parametrize ij version after 1.3.70
+        isTransitive = false
+    }
+
+    val idea_version: String by project
+    intellijCore("com.jetbrains.intellij.idea:intellij-core:$idea_version")
+    implementation(intellijCoreAnalysis())
+
+    implementation("org.jetbrains:markdown:0.1.41") {
+        because("it's published only on bintray")
+    }
+}
+
+tasks {
+    shadowJar {
+        val dokka_version: String by project
+        archiveFileName.set("dokka-kotlin-analysis-dependencies-$dokka_version.jar")
+        archiveClassifier.set("")
+
+        exclude("colorScheme/**")
+        exclude("fileTemplates/**")
+        exclude("inspectionDescriptions/**")
+        exclude("intentionDescriptions/**")
+        exclude("tips/**")
+        exclude("messages/**")
+        exclude("src/**")
+        exclude("**/*.kotlin_metadata")
+        exclude("**/*.kotlin_builtins")
+    }
+}
+
+
+publishing {
+    publications {
+        register<MavenPublication>("kotlin-analysis-dependencies") {
+            artifactId = "kotlin-analysis-dependencies"
+            project.shadow.component(this)
+        }
+    }
+}
+
+configureBintrayPublication("kotlin-analysis-dependencies")
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
new file mode 100644
index 00000000..7836bde9
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt
@@ -0,0 +1,636 @@
+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.MockComponentManager
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.extensions.Extensions
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.module.ModuleManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.OrderEnumerationHandler
+import com.intellij.openapi.roots.ProjectFileIndex
+import com.intellij.openapi.roots.ProjectRootManager
+import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.vfs.StandardFileSystems
+import com.intellij.psi.PsiElement
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.dokka.Platform
+import org.jetbrains.kotlin.analyzer.*
+import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters
+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.resolve.*
+import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
+import org.jetbrains.kotlin.cli.common.config.ContentRoot
+import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
+import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
+import org.jetbrains.kotlin.cli.jvm.config.*
+import org.jetbrains.kotlin.cli.jvm.index.JavaRoot
+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.analyzer.NativeResolverForModuleFactory
+import org.jetbrains.kotlin.js.config.JSConfigurationKeys
+import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
+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.psi.*
+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.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.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.descriptors.konan.KlibModuleOrigin
+import org.jetbrains.kotlin.extensions.ApplicationExtensionDescriptor
+import org.jetbrains.kotlin.ide.konan.NativePlatformKindResolution
+import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaClass
+import org.jetbrains.kotlin.platform.IdePlatformKind
+import org.jetbrains.kotlin.platform.impl.CommonIdePlatformKind
+import org.jetbrains.kotlin.platform.impl.JsIdePlatformKind
+import org.jetbrains.kotlin.platform.impl.JvmIdePlatformKind
+import org.jetbrains.kotlin.platform.impl.NativeIdePlatformKind
+import org.jetbrains.kotlin.platform.konan.NativePlatforms
+import java.io.File
+
+const val JAR_SEPARATOR = "!/"
+const val KLIB_EXTENSION = "klib"
+
+/**
+ * Kotlin as a service entry point
+ *
+ * Configures environment, analyses files and provides facilities to perform code processing without emitting bytecode
+ *
+ * $messageCollector: required by compiler infrastructure and will receive all compiler messages
+ * $body: optional and can be used to configure environment without creating local variable
+ */
+class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPlatform: Platform) : Disposable {
+    val configuration = CompilerConfiguration()
+
+    init {
+        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
+    }
+
+    fun createCoreEnvironment(): KotlinCoreEnvironment {
+        System.setProperty("idea.io.use.nio2", "true")
+
+        val configFiles = when (analysisPlatform) {
+            Platform.jvm, Platform.common -> EnvironmentConfigFiles.JVM_CONFIG_FILES
+            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 moduleManager = object : CoreModuleManager(environment.project, this) {
+            override fun getModules(): Array<out Module> = arrayOf(projectFileIndex.module)
+        }
+
+        CoreApplicationEnvironment.registerComponentInstance(
+            projectComponentManager.picoContainer,
+            ModuleManager::class.java, moduleManager
+        )
+
+        CoreApplicationEnvironment.registerExtensionPoint(
+            Extensions.getRootArea(),
+            OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java
+        )
+
+        projectComponentManager.registerService(
+            ProjectFileIndex::class.java,
+            projectFileIndex
+        )
+
+        projectComponentManager.registerService(
+            ProjectRootManager::class.java,
+            CoreProjectRootManager(projectFileIndex)
+        )
+
+        registerExtensionPoint(
+            ApplicationExtensionDescriptor("org.jetbrains.kotlin.idePlatformKind", IdePlatformKind::class.java),
+            listOf(
+                CommonIdePlatformKind,
+                JvmIdePlatformKind,
+                JsIdePlatformKind,
+                NativeIdePlatformKind
+            )
+        )
+
+        registerExtensionPoint(
+            IdePlatformKindResolution,
+            listOf(
+                CommonPlatformKindResolution(),
+                JvmPlatformKindResolution(),
+                JsPlatformKindResolution(),
+                NativePlatformKindResolution()
+            )
+        )
+
+        return environment
+    }
+
+    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()
+            )
+        }
+
+    fun createResolutionFacade(environment: KotlinCoreEnvironment): Pair<DokkaResolutionFacade, DokkaResolutionFacade> {
+        val projectContext = ProjectContext(environment.project, "Dokka")
+        val sourceFiles = environment.getSourceFiles()
+
+
+        val targetPlatform = when (analysisPlatform) {
+            Platform.js -> JsPlatforms.defaultJsPlatform
+            Platform.common -> CommonPlatforms.defaultCommonPlatform
+            Platform.native -> NativePlatforms.unspecifiedNativePlatform
+            Platform.jvm -> JvmPlatforms.defaultJvmPlatform
+        }
+
+        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 val platform: TargetPlatform = targetPlatform
+            override fun dependencies(): List<ModuleInfo> = listOf(this, library) + nativeLibraries
+        }
+
+        val sourcesScope = createSourceModuleSearchScope(environment.project, sourceFiles)
+        val modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo> = {
+            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")
+            }
+        }
+
+        var builtIns: JvmBuiltIns? = null
+
+        val resolverForProject = when (analysisPlatform) {
+            Platform.jvm -> {
+                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.js -> createJsResolverForProject(projectContext, module, library, modulesContent)
+            Platform.native -> createNativeResolverForProject(projectContext, module, library, modulesContent)
+
+        }
+        val libraryModuleDescriptor = resolverForProject.descriptorForModule(library)
+        val moduleDescriptor = resolverForProject.descriptorForModule(module)
+        builtIns?.initialize(moduleDescriptor, true)
+
+        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)
+        )
+
+        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 = 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 + (KlibModuleOrigin.CAPABILITY to kotlinLibrary)
+        }
+    }
+
+    private fun createCommonResolverForProject(
+        projectContext: ProjectContext,
+        module: ModuleInfo,
+        library: LibraryModuleInfo,
+        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
+        environment: KotlinCoreEnvironment
+    ): 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(
+        projectContext: ProjectContext,
+        module: ModuleInfo,
+        library: LibraryModuleInfo,
+        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
+    ): 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(
+        projectContext: ProjectContext,
+        module: ModuleInfo,
+        library: LibraryModuleInfo,
+        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
+    ): 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 {
+
+                return NativeResolverForModuleFactory(
+                    PlatformAnalysisParameters.Empty,
+                    CompilerEnvironment,
+                    NativePlatforms.unspecifiedNativePlatform
+                ).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(
+        projectContext: ProjectContext,
+        module: ModuleInfo,
+        library: LibraryModuleInfo,
+        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
+        sourcesScope: GlobalSearchScope,
+        builtIns: KotlinBuiltIns
+    ): ResolverForProject<ModuleInfo> {
+        val javaRoots = classpath
+            .mapNotNull {
+                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 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")
+                }
+
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = builtIns
+
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule = JvmResolverForModuleFactory(
+                JvmPlatformParameters({ content ->
+                    JvmPackagePartProvider(
+                        configuration.languageVersionSettings,
+                        content.moduleContentScope
+                    )
+                        .apply {
+                            addRoots(javaRoots, messageCollector)
+                        }
+                }, {
+                    val file =  (it as? BinaryJavaClass)?.virtualFile ?: (it as JavaClassImpl).psi.containingFile.virtualFile
+                    if (file in sourcesScope)
+                        module
+                    else
+                        library
+                }),
+                CompilerEnvironment,
+                unspecifiedJvmPlatform
+            ).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)
+        configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
+    }
+
+    /**
+     * Classpath for this environment.
+     */
+    val classpath: List<File>
+        get() = configuration.jvmClasspathRoots
+
+    /**
+     * Adds list of paths to classpath.
+     * $paths: collection of files to add
+     */
+    fun addClasspath(paths: List<File>) {
+        if (analysisPlatform == Platform.js) {
+            configuration.addAll(JSConfigurationKeys.LIBRARIES, paths.map { it.absolutePath })
+        }
+        configuration.addJvmClasspathRoots(paths)
+    }
+
+    /**
+     * Adds path to classpath.
+     * $path: path to add
+     */
+    fun addClasspath(path: File) {
+        if (analysisPlatform == Platform.js) {
+            configuration.add(JSConfigurationKeys.LIBRARIES, path.absolutePath)
+        }
+        configuration.addJvmClasspathRoot(path)
+    }
+
+    /**
+     * List of source roots for this environment.
+     */
+    val sources: List<String>
+        get() = configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
+            ?.filterIsInstance<KotlinSourceRoot>()
+            ?.map { it.path } ?: emptyList()
+
+    /**
+     * Adds list of paths to source roots.
+     * $list: collection of files to add
+     */
+    fun addSources(list: List<String>) {
+        list.forEach {
+            configuration.addKotlinSourceRoot(it)
+            val file = File(it)
+            if (file.isDirectory || file.extension == ".java") {
+                configuration.addJavaSourceRoot(file)
+            }
+        }
+    }
+
+    fun addRoots(list: List<ContentRoot>) {
+        configuration.addAll(CLIConfigurationKeys.CONTENT_ROOTS, list)
+    }
+
+    /**
+     * Disposes the environment and frees all associated resources.
+     */
+    override fun dispose() {
+        Disposer.dispose(this)
+    }
+
+    companion object {
+        private fun <T : Any> registerExtensionPoint(
+            appExtension: ApplicationExtensionDescriptor<T>,
+            instances: List<T>
+        ) {
+            if (Extensions.getRootArea().hasExtensionPoint(appExtension.extensionPointName))
+                return
+
+            appExtension.registerExtensionPoint()
+            instances.forEach(appExtension::registerExtension)
+        }
+    }
+}
+
+fun contentRootFromPath(path: String): ContentRoot {
+    val file = File(path)
+    return if (file.extension == "java") JavaSourceRoot(file, null) else KotlinSourceRoot(path, false)
+}
+
+
+class DokkaResolutionFacade(
+    override val project: Project,
+    override val moduleDescriptor: ModuleDescriptor,
+    val resolverForModule: ResolverForModule
+) : ResolutionFacade {
+    override fun analyzeWithAllCompilerChecks(elements: Collection<KtElement>): AnalysisResult {
+        throw UnsupportedOperationException()
+    }
+
+    override fun <T : Any> tryGetFrontendService(element: PsiElement, serviceClass: Class<T>): T? {
+        return resolverForModule.componentProvider.tryGetService(serviceClass)
+    }
+
+    override fun resolveToDescriptor(
+        declaration: KtDeclaration,
+        bodyResolveMode: BodyResolveMode
+    ): DeclarationDescriptor {
+        return resolveSession.resolveToDescriptor(declaration)
+    }
+
+    override fun analyze(elements: Collection<KtElement>, bodyResolveMode: BodyResolveMode): BindingContext {
+        throw UnsupportedOperationException()
+    }
+
+    val resolveSession: ResolveSession get() = getFrontendService(ResolveSession::class.java)
+
+    override fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
+        if (element is KtDeclaration) {
+            val descriptor = resolveToDescriptor(element)
+            return object : BindingContext {
+                override fun <K : Any?, V : Any?> getKeys(p0: WritableSlice<K, V>?): Collection<K> {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun getType(p0: KtExpression): KotlinType? {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun <K : Any?, V : Any?> get(slice: ReadOnlySlice<K, V>?, key: K): V? {
+                    if (key != element) {
+                        throw UnsupportedOperationException()
+                    }
+                    return when {
+                        slice == BindingContext.DECLARATION_TO_DESCRIPTOR -> descriptor as V
+                        slice == BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER && (element as KtParameter).hasValOrVar() -> descriptor as V
+                        else -> null
+                    }
+                }
+
+                override fun getDiagnostics(): Diagnostics {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun addOwnDataTo(p0: BindingTrace, p1: Boolean) {
+                    throw UnsupportedOperationException()
+                }
+
+                override fun <K : Any?, V : Any?> getSliceContents(p0: ReadOnlySlice<K, V>): ImmutableMap<K, V> {
+                    throw UnsupportedOperationException()
+                }
+
+            }
+        }
+        throw UnsupportedOperationException()
+    }
+
+    override fun <T : Any> getFrontendService(element: PsiElement, serviceClass: Class<T>): T {
+        throw UnsupportedOperationException()
+    }
+
+    override fun <T : Any> getFrontendService(serviceClass: Class<T>): T {
+        return resolverForModule.componentProvider.getService(serviceClass)
+    }
+
+    override fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
+        return resolverForModule.componentProvider.getService(serviceClass)
+    }
+
+    override fun <T : Any> getIdeService(serviceClass: Class<T>): T {
+        throw UnsupportedOperationException()
+    }
+
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CallableFactory.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CallableFactory.kt
new file mode 100644
index 00000000..ebfe20a5
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CallableFactory.kt
@@ -0,0 +1,31 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.psi.PsiField
+import com.intellij.psi.PsiMethod
+import org.jetbrains.dokka.links.Callable
+import org.jetbrains.dokka.links.JavaClassReference
+import org.jetbrains.dokka.links.TypeReference
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+
+fun Callable.Companion.from(descriptor: CallableDescriptor) = with(descriptor) {
+    Callable(
+        name.asString(),
+        extensionReceiverParameter?.let { TypeReference.from(it) },
+        valueParameters.mapNotNull { TypeReference.from(it) }
+    )
+}
+
+fun Callable.Companion.from(psi: PsiMethod) = with(psi) {
+    Callable(
+        name,
+        null,
+        parameterList.parameters.map { param -> JavaClassReference(param.type.canonicalText) })
+}
+
+fun Callable.Companion.from(psi: PsiField): Callable {
+    return Callable(
+        name = psi.name,
+        receiver = null,
+        params = emptyList()
+    )
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CoreKotlinCacheService.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CoreKotlinCacheService.kt
new file mode 100644
index 00000000..68415875
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CoreKotlinCacheService.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.psi.PsiFile
+import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+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.diagnostics.KotlinSuppressCache
+
+
+class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade) : KotlinCacheService {
+    override fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
+        return resolutionFacade
+    }
+
+    override fun getResolutionFacade(
+        elements: List<KtElement>,
+        platform: org.jetbrains.kotlin.platform.TargetPlatform
+    ): ResolutionFacade {
+        return 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
+    }
+
+    override fun getSuppressionCache(): KotlinSuppressCache {
+        throw UnsupportedOperationException()
+    }
+
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CoreProjectFileIndex.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CoreProjectFileIndex.kt
new file mode 100644
index 00000000..d0e0bb4f
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/CoreProjectFileIndex.kt
@@ -0,0 +1,515 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.components.BaseComponent
+import com.intellij.openapi.extensions.ExtensionPointName
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.projectRoots.Sdk
+import com.intellij.openapi.projectRoots.SdkAdditionalData
+import com.intellij.openapi.projectRoots.SdkModificator
+import com.intellij.openapi.projectRoots.SdkTypeId
+import com.intellij.openapi.roots.*
+import com.intellij.openapi.roots.impl.ProjectOrderEnumerator
+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
+import com.intellij.util.messages.MessageBus
+import org.jetbrains.jps.model.module.JpsModuleSourceRootType
+import org.jetbrains.kotlin.cli.common.config.ContentRoot
+import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
+import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
+import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
+import org.picocontainer.PicoContainer
+import java.io.File
+
+/**
+ * Workaround for the lack of ability to create a ProjectFileIndex implementation using only
+ * classes from projectModel-{api,impl}.
+ */
+class CoreProjectFileIndex(private val project: Project, contentRoots: List<ContentRoot>) : ProjectFileIndex, ModuleFileIndex {
+    override fun iterateContent(p0: ContentIterator, p1: VirtualFileFilter?): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator, p2: VirtualFileFilter?): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInLibrary(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    val sourceRoots = contentRoots.filter { it !is JvmClasspathRoot }
+    val classpathRoots = contentRoots.filterIsInstance<JvmClasspathRoot>()
+
+    val module: Module = object : UserDataHolderBase(), Module {
+        override fun isDisposed(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getName(): String = "<Dokka module>"
+
+        override fun getModuleWithLibrariesScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleWithDependentsScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleWithDependenciesScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleWithDependenciesAndLibrariesScope(p0: Boolean): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleTestsWithDependentsScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleScope(): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleRuntimeScope(p0: Boolean): GlobalSearchScope {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> getExtensions(p0: ExtensionPointName<T>): Array<out T> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> getComponent(interfaceClass: Class<T>): T? {
+            if (interfaceClass == ModuleRootManager::class.java) {
+                return moduleRootManager as T
+            }
+            throw UnsupportedOperationException()
+        }
+
+        override fun getDisposed(): Condition<*> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getPicoContainer(): PicoContainer {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getMessageBus(): MessageBus {
+            throw UnsupportedOperationException()
+        }
+
+        override fun dispose() {
+            throw UnsupportedOperationException()
+        }
+    }
+
+    private val sdk: Sdk = object : Sdk, RootProvider {
+        override fun getFiles(rootType: OrderRootType): Array<out VirtualFile> = classpathRoots
+                .mapNotNull { StandardFileSystems.local().findFileByPath(it.file.path) }
+                .toTypedArray()
+
+        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
+            throw UnsupportedOperationException()
+        }
+
+        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener, p1: Disposable) {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getUrls(p0: OrderRootType): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun removeRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSdkModificator(): SdkModificator {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getName(): String = "<dokka SDK>"
+
+        override fun getRootProvider(): RootProvider = this
+
+        override fun getHomePath(): String? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getVersionString(): String? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSdkAdditionalData(): SdkAdditionalData? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun clone(): Any {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSdkType(): SdkTypeId {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getHomeDirectory(): VirtualFile? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> getUserData(p0: Key<T>): T? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <T : Any?> putUserData(p0: Key<T>, p1: T?) {
+            throw UnsupportedOperationException()
+        }
+    }
+
+    private val moduleSourceOrderEntry = object : ModuleSourceOrderEntry {
+        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getUrls(p0: OrderRootType): Array<String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
+            throw UnsupportedOperationException()
+        }
+
+
+        override fun getPresentableName(): String {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getOwnerModule(): Module = module
+
+
+        override fun isValid(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun compareTo(other: OrderEntry?): Int {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getRootModel(): ModuleRootModel = moduleRootManager
+
+        override fun isSynthetic(): Boolean {
+            throw UnsupportedOperationException()
+        }
+    }
+
+    private val sdkOrderEntry = object : JdkOrderEntry {
+        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getUrls(p0: OrderRootType): Array<String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getJdkName(): String? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getJdk(): Sdk = sdk
+
+        override fun getPresentableName(): String {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getOwnerModule(): Module {
+            throw UnsupportedOperationException()
+        }
+
+        override fun isValid(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getRootFiles(p0: OrderRootType): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getRootUrls(p0: OrderRootType): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun compareTo(other: OrderEntry?): Int {
+            throw UnsupportedOperationException()
+        }
+
+        override fun isSynthetic(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+    }
+
+    inner class MyModuleRootManager : ModuleRootManager() {
+        override fun getExternalSource(): ProjectModelExternalSource? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getExcludeRoots(): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getContentEntries(): Array<out ContentEntry> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getExcludeRootUrls(): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun <R : Any?> processOrder(p0: RootPolicy<R>, p1: R): R {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRoots(p0: Boolean): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRoots(): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRoots(p0: JpsModuleSourceRootType<*>): MutableList<VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getContentRoots(): Array<out VirtualFile> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun orderEntries(): OrderEnumerator =
+                ProjectOrderEnumerator(project, null).using(object : RootModelProvider {
+                    override fun getModules(): Array<out Module> = arrayOf(module)
+
+                    override fun getRootModel(p0: Module): ModuleRootModel = this@MyModuleRootManager
+                })
+
+        override fun <T : Any?> getModuleExtension(p0: Class<T>): T {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getDependencyModuleNames(): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModule(): Module = this@CoreProjectFileIndex.module
+
+        override fun isSdkInherited(): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getOrderEntries(): Array<out OrderEntry> = arrayOf(moduleSourceOrderEntry, sdkOrderEntry)
+
+        override fun getSourceRootUrls(): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSourceRootUrls(p0: Boolean): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getSdk(): Sdk? {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getContentRootUrls(): Array<out String> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleDependencies(): Array<out Module> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModuleDependencies(p0: Boolean): Array<out Module> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getModifiableModel(): ModifiableRootModel {
+            throw UnsupportedOperationException()
+        }
+
+        override fun isDependsOn(p0: Module): Boolean {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getFileIndex(): ModuleFileIndex {
+            return this@CoreProjectFileIndex
+        }
+
+        override fun getDependencies(): Array<out Module> {
+            throw UnsupportedOperationException()
+        }
+
+        override fun getDependencies(p0: Boolean): Array<out Module> {
+            throw UnsupportedOperationException()
+        }
+    }
+
+    val moduleRootManager = MyModuleRootManager()
+
+    override fun getContentRootForFile(p0: VirtualFile): VirtualFile? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentRootForFile(p0: VirtualFile, p1: Boolean): VirtualFile? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getPackageNameByDirectory(p0: VirtualFile): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInLibrarySource(file: VirtualFile): Boolean = false
+
+    override fun getClassRootForFile(file: VirtualFile): VirtualFile? =
+        classpathRoots.firstOrNull { it.contains(file) }?.let { StandardFileSystems.local().findFileByPath(it.file.path) }
+
+    override fun getOrderEntriesForFile(file: VirtualFile): List<OrderEntry> =
+        if (classpathRoots.contains(file)) listOf(sdkOrderEntry) else emptyList()
+
+    override fun isInLibraryClasses(file: VirtualFile): Boolean = classpathRoots.contains(file)
+
+    override fun isExcluded(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getSourceRootForFile(p0: VirtualFile): VirtualFile? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isUnderIgnored(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isLibraryClassFile(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getModuleForFile(file: VirtualFile): Module? =
+            if (sourceRoots.contains(file)) module else null
+
+    private fun List<ContentRoot>.contains(file: VirtualFile): Boolean = any { it.contains(file) }
+
+    override fun getModuleForFile(p0: VirtualFile, p1: Boolean): Module? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInSource(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isIgnored(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isContentSourceFile(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInSourceContent(file: VirtualFile): Boolean = sourceRoots.contains(file)
+
+    override fun iterateContent(p0: ContentIterator): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInContent(p0: VirtualFile): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun isInTestSourceContent(file: VirtualFile): Boolean = false
+
+    override fun isUnderSourceRootOfType(p0: VirtualFile, p1: MutableSet<out JpsModuleSourceRootType<*>>): Boolean {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getOrderEntryForFile(p0: VirtualFile): OrderEntry? {
+        throw UnsupportedOperationException()
+    }
+}
+
+class CoreProjectRootManager(val projectFileIndex: CoreProjectFileIndex) : ProjectRootManager() {
+    override fun orderEntries(): OrderEnumerator {
+        throw UnsupportedOperationException()
+    }
+
+    override fun orderEntries(p0: MutableCollection<out Module>): OrderEnumerator {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentRootsFromAllModules(): Array<out VirtualFile> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun setProjectSdk(p0: Sdk?) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun setProjectSdkName(p0: String) {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getModuleSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentSourceRoots(): Array<out VirtualFile> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getFileIndex(): ProjectFileIndex = projectFileIndex
+
+    override fun getProjectSdkName(): String? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getProjectSdk(): Sdk? {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentRoots(): Array<out VirtualFile> {
+        throw UnsupportedOperationException()
+    }
+
+    override fun getContentRootUrls(): MutableList<String> {
+        throw UnsupportedOperationException()
+    }
+
+}
+
+fun ContentRoot.contains(file: VirtualFile) = when (this) {
+    is JvmContentRoot -> {
+        val path = if (file.fileSystem.protocol == StandardFileSystems.JAR_PROTOCOL)
+            getVirtualFileForJar(file)?.path ?: file.path
+        else
+            file.path
+        File(path).startsWith(this.file.absoluteFile)
+    }
+    is KotlinSourceRoot -> File(file.path).startsWith(File(this.path).absoluteFile)
+    else -> false
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DRIFactory.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DRIFactory.kt
new file mode 100644
index 00000000..513817f3
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DRIFactory.kt
@@ -0,0 +1,38 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiField
+import com.intellij.psi.PsiMethod
+import org.jetbrains.dokka.links.Callable
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.links.DriTarget
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
+import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+
+fun DRI.Companion.from(descriptor: DeclarationDescriptor) = descriptor.parentsWithSelf.run {
+    val callable = firstIsInstanceOrNull<CallableDescriptor>()
+    DRI(
+        firstIsInstanceOrNull<PackageFragmentDescriptor>()?.fqName?.asString(),
+        (filterIsInstance<ClassDescriptor>() + filterIsInstance<TypeAliasDescriptor>()).toList()
+            .takeIf { it.isNotEmpty() }
+            ?.asReversed()
+            ?.joinToString(separator = ".") { it.name.asString() },
+        callable?.let { Callable.from(it) },
+        DriTarget.from(descriptor)
+    )
+}
+
+fun DRI.Companion.from(psi: PsiElement) = psi.parentsWithSelf.run {
+    val psiMethod = firstIsInstanceOrNull<PsiMethod>()
+    val psiField = firstIsInstanceOrNull<PsiField>()
+    val classes = filterIsInstance<PsiClass>().toList()
+    DRI(
+        classes.lastOrNull()?.qualifiedName?.substringBeforeLast('.', ""),
+        classes.toList().takeIf { it.isNotEmpty() }?.asReversed()?.mapNotNull { it.name }?.joinToString("."),
+        psiMethod?.let { Callable.from(it) } ?: psiField?.let { Callable.from(it) },
+        DriTarget.from(psi)
+    )
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DRITargetFactory.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DRITargetFactory.kt
new file mode 100644
index 00000000..031a5a32
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DRITargetFactory.kt
@@ -0,0 +1,44 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiMethod
+import com.intellij.psi.PsiParameter
+import com.intellij.psi.PsiTypeParameter
+import org.jetbrains.dokka.links.DriTarget
+import org.jetbrains.dokka.links.PointingToCallableParameters
+import org.jetbrains.dokka.links.PointingToDeclaration
+import org.jetbrains.dokka.links.PointingToGenericParameters
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ParameterDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
+import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+
+fun DriTarget.Companion.from(descriptor: DeclarationDescriptor): DriTarget = descriptor.parentsWithSelf.run {
+    return when (descriptor) {
+        is TypeParameterDescriptor -> PointingToGenericParameters(descriptor.index)
+        else -> {
+            val callable = firstIsInstanceOrNull<CallableDescriptor>()
+            val params =
+                callable?.let { listOfNotNull(it.extensionReceiverParameter) + it.valueParameters }.orEmpty()
+            val parameterDescriptor = firstIsInstanceOrNull<ParameterDescriptor>()
+
+            parameterDescriptor?.let { PointingToCallableParameters(params.indexOf(it)) }
+                ?: PointingToDeclaration
+        }
+    }
+}
+
+
+fun DriTarget.Companion.from(psi: PsiElement): DriTarget = psi.parentsWithSelf.run {
+    return when (psi) {
+        is PsiTypeParameter -> PointingToGenericParameters(psi.index)
+        else -> firstIsInstanceOrNull<PsiParameter>()?.let {
+            val callable = firstIsInstanceOrNull<PsiMethod>()
+            val params = (callable?.parameterList?.parameters).orEmpty()
+            PointingToCallableParameters(params.indexOf(it))
+        } ?: PointingToDeclaration
+    }
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/Documentable.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/Documentable.kt
new file mode 100644
index 00000000..0c55fed4
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/Documentable.kt
@@ -0,0 +1,14 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.psi.PsiNamedElement
+import org.jetbrains.dokka.model.DocumentableSource
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.load.kotlin.toSourceElement
+
+class DescriptorDocumentableSource(val descriptor: DeclarationDescriptor) : DocumentableSource {
+    override val path = descriptor.toSourceElement.containingFile.toString()
+}
+
+class PsiDocumentableSource(val psi: PsiNamedElement) : DocumentableSource {
+    override val path = psi.containingFile.virtualFile.path
+}
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
new file mode 100644
index 00000000..9d15123a
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/EnvironmentAndFacade.kt
@@ -0,0 +1,59 @@
+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.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.utils.PathUtil
+import java.io.File
+
+internal fun createEnvironmentAndFacade(
+    logger: DokkaLogger,
+    configuration: DokkaConfiguration,
+    pass: DokkaConfiguration.PassConfiguration
+): EnvironmentAndFacade =
+    AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
+        if (analysisPlatform == Platform.jvm) {
+            addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
+        }
+        pass.classpath.forEach { addClasspath(File(it)) }
+
+        addSources(
+            (pass.sourceRoots + configuration.passesConfigurations.filter { it.sourceSetID in pass.dependentSourceSets }
+                .flatMap { it.sourceRoots })
+                .map { it.path }
+        )
+
+        loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
+
+        val environment = createCoreEnvironment()
+        val (facade, _) = createResolutionFacade(environment)
+        EnvironmentAndFacade(environment, facade)
+    }
+
+class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
+    override fun clear() {
+        seenErrors = false
+    }
+
+    private var seenErrors = false
+
+    override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
+        if (severity == CompilerMessageSeverity.ERROR) {
+            seenErrors = true
+        }
+        logger.info(MessageRenderer.PLAIN_FULL_PATHS.render(severity, message, location))
+    }
+
+    override fun hasErrors() = seenErrors
+}
+
+// It is not data class due to ill-defined equals
+class EnvironmentAndFacade(val environment: KotlinCoreEnvironment, val facade: DokkaResolutionFacade) {
+    operator fun component1() = environment
+    operator fun component2() = facade
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/JavaResolveExtension.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/JavaResolveExtension.kt
new file mode 100644
index 00000000..ab6bec9c
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/JavaResolveExtension.kt
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:JvmName("JavaResolutionUtils")
+
+package org.jetbrains.dokka.analysis
+
+import com.intellij.psi.*
+import org.jetbrains.kotlin.asJava.unwrapped
+import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+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.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+
+// TODO: Remove that file
+
+@JvmOverloads
+fun PsiMethod.getJavaMethodDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    val method = originalElement as? PsiMethod ?: return null
+    if (method.containingClass == null || !Name.isValidIdentifier(method.name)) return null
+    val resolver = method.getJavaDescriptorResolver(resolutionFacade)
+    return when {
+        method.isConstructor -> resolver?.resolveConstructor(JavaConstructorImpl(method))
+        else -> resolver?.resolveMethod(JavaMethodImpl(method))
+    }
+}
+
+@JvmOverloads
+fun PsiClass.getJavaClassDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): ClassDescriptor? {
+    val psiClass = originalElement as? PsiClass ?: return null
+    return psiClass.getJavaDescriptorResolver(resolutionFacade)?.resolveClass(JavaClassImpl(psiClass))
+}
+
+@JvmOverloads
+fun PsiField.getJavaFieldDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): PropertyDescriptor? {
+    val field = originalElement as? PsiField ?: return null
+    return field.getJavaDescriptorResolver(resolutionFacade)?.resolveField(JavaFieldImpl(field))
+}
+
+@JvmOverloads
+fun PsiMember.getJavaMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    return when (this) {
+        is PsiEnumConstant -> containingClass?.getJavaClassDescriptor(resolutionFacade)
+        is PsiClass -> getJavaClassDescriptor(resolutionFacade)
+        is PsiMethod -> getJavaMethodDescriptor(resolutionFacade)
+        is PsiField -> getJavaFieldDescriptor(resolutionFacade)
+        else -> null
+    }
+}
+
+@JvmOverloads
+fun PsiMember.getJavaOrKotlinMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
+    val callable = unwrapped
+    return when (callable) {
+        is PsiMember -> getJavaMemberDescriptor(resolutionFacade)
+        is KtDeclaration -> {
+            val descriptor = resolutionFacade.resolveToDescriptor(callable)
+            if (descriptor is ClassDescriptor && this is PsiMethod) descriptor.unsubstitutedPrimaryConstructor else descriptor
+        }
+        else -> null
+    }
+}
+
+private fun PsiElement.getJavaDescriptorResolver(resolutionFacade: ResolutionFacade): JavaDescriptorResolver? {
+    return resolutionFacade.tryGetFrontendService(this, JavaDescriptorResolver::class.java)
+}
+
+private fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): DeclarationDescriptor? {
+    return getContainingScope(method)
+            ?.getContributedDescriptors(nameFilter = { true }, kindFilter = DescriptorKindFilter.CALLABLES)
+            ?.filterIsInstance<DeclarationDescriptorWithSource>()
+            ?.findByJavaElement(method)
+}
+
+private fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructor): ConstructorDescriptor? {
+    return resolveClass(constructor.containingClass)?.constructors?.findByJavaElement(constructor)
+}
+
+private fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescriptor? {
+    return getContainingScope(field)?.getContributedVariables(field.name, NoLookupLocation.FROM_IDE)?.findByJavaElement(field)
+}
+
+private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): MemberScope? {
+    val containingClass = resolveClass(member.containingClass)
+    return if (member.isStatic)
+        containingClass?.staticScope
+    else
+        containingClass?.defaultType?.memberScope
+}
+
+private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {
+    return firstOrNull { member ->
+        val memberJavaElement = (member.original.source as? JavaSourceElement)?.javaElement
+        when {
+            memberJavaElement == javaElement ->
+                true
+            memberJavaElement is JavaElementImpl<*> && javaElement is JavaElementImpl<*> ->
+                memberJavaElement.psi.isEquivalentTo(javaElement.psi)
+            else ->
+                false
+        }
+    }
+}
+
+fun PsiElement.javaResolutionFacade() =
+    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatforms.defaultJvmPlatform)!!
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
new file mode 100644
index 00000000..cd07b2a3
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
@@ -0,0 +1,46 @@
+@file:Suppress("FunctionName")
+
+package org.jetbrains.dokka.analysis
+
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.model.SourceSetCache
+import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.model.SourceSetDependent
+import org.jetbrains.dokka.plugability.DokkaContext
+
+fun KotlinAnalysis(context: DokkaContext): KotlinAnalysis {
+    val environments = context.configuration.passesConfigurations
+        .associate { passConfiguration ->
+            context.sourceSetCache.getSourceSet(passConfiguration) to createEnvironmentAndFacade(
+                logger = context.logger,
+                configuration = context.configuration,
+                pass = passConfiguration
+            )
+        }
+
+    return KotlinAnalysisImpl(context.sourceSetCache, environments)
+}
+
+interface KotlinAnalysis : SourceSetDependent<EnvironmentAndFacade> {
+    override fun get(key: SourceSetData): EnvironmentAndFacade
+    operator fun get(sourceSetID: String): EnvironmentAndFacade
+    operator fun get(passConfiguration: DokkaConfiguration.PassConfiguration): EnvironmentAndFacade
+}
+
+internal class KotlinAnalysisImpl(
+    private val sourceSetCache: SourceSetCache,
+    private val environments: SourceSetDependent<EnvironmentAndFacade>
+) : KotlinAnalysis, SourceSetDependent<EnvironmentAndFacade> by environments {
+
+    override fun get(key: SourceSetData): EnvironmentAndFacade {
+        return environments[key] ?: throw IllegalStateException("Missing EnvironmentAndFacade for sourceSet $key")
+    }
+
+    override fun get(sourceSetID: String): EnvironmentAndFacade {
+        return environments.entries.first { (sourceSet, _) -> sourceSet.sourceSetID == sourceSetID }.value
+    }
+
+    override fun get(passConfiguration: DokkaConfiguration.PassConfiguration): EnvironmentAndFacade {
+        return get(sourceSetCache.getSourceSet(passConfiguration))
+    }
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/TypeReferenceFactory.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/TypeReferenceFactory.kt
new file mode 100644
index 00000000..e07672d4
--- /dev/null
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/TypeReferenceFactory.kt
@@ -0,0 +1,51 @@
+package org.jetbrains.dokka.analysis
+
+import com.intellij.psi.PsiClass
+import org.jetbrains.dokka.links.*
+import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.TypeProjection
+
+fun TypeReference.Companion.from(d: ReceiverParameterDescriptor): TypeReference? =
+    when (d.value) {
+        is ExtensionReceiver -> fromPossiblyNullable(d.type)
+        else -> run {
+            println("Unknown value type for $d")
+            null
+        }
+    }
+
+fun TypeReference.Companion.from(d: ValueParameterDescriptor): TypeReference? =
+    fromPossiblyNullable(d.type)
+
+fun TypeReference.Companion.from(p: PsiClass) = TypeReference
+
+private fun TypeReference.Companion.fromPossiblyNullable(t: KotlinType, self: KotlinType? = null): TypeReference =
+    from(t, self).let { if (t.isMarkedNullable) Nullable(it) else it }
+
+private fun TypeReference.Companion.from(t: KotlinType, self: KotlinType? = null): TypeReference =
+    if (self is KotlinType && self.constructor == t.constructor && self.arguments == t.arguments)
+        SelfType
+    else when (val d = t.constructor.declarationDescriptor) {
+        is TypeParameterDescriptor -> TypeParam(
+            d.upperBounds.map { fromPossiblyNullable(it, self ?: t) }
+        )
+        else -> TypeConstructor(
+            t.constructorName.orEmpty(),
+            t.arguments.map { fromProjection(it, self) }
+        )
+    }
+
+private fun TypeReference.Companion.fromProjection(t: TypeProjection, r: KotlinType? = null): TypeReference =
+    if (t.isStarProjection) {
+        StarProjection
+    } else {
+        fromPossiblyNullable(t.type, r)
+    }
+
+private val KotlinType.constructorName
+    get() = constructor.declarationDescriptor?.fqNameSafe?.asString()
diff --git a/plugins/base/build.gradle.kts b/plugins/base/build.gradle.kts
index 24a7f593..97d6a646 100644
--- a/plugins/base/build.gradle.kts
+++ b/plugins/base/build.gradle.kts
@@ -5,6 +5,7 @@ plugins {
 }
 
 dependencies {
+    api(project(":kotlin-analysis"))
     implementation("org.jsoup:jsoup:1.12.1")
     implementation("org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10")
     testImplementation(project(":test-tools"))
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index cf4ad88f..f1b0d969 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -1,6 +1,9 @@
+@file:Suppress("unused")
+
 package org.jetbrains.dokka.base
 
 import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.analysis.KotlinAnalysis
 import org.jetbrains.dokka.base.allModulePage.MultimodulePageCreator
 import org.jetbrains.dokka.base.renderers.*
 import org.jetbrains.dokka.base.renderers.html.*
@@ -37,13 +40,19 @@ class DokkaBase : DokkaPlugin() {
     val externalLocationProviderFactory by extensionPoint<ExternalLocationProviderFactory>()
     val outputWriter by extensionPoint<OutputWriter>()
     val htmlPreprocessors by extensionPoint<PageTransformer>()
+    val kotlinAnalysis by extensionPoint<KotlinAnalysis>()
+
 
     val descriptorToDocumentableTranslator by extending {
-        CoreExtensions.sourceToDocumentableTranslator with DefaultDescriptorToDocumentableTranslator
+        CoreExtensions.sourceToDocumentableTranslator providing { ctx ->
+            DefaultDescriptorToDocumentableTranslator(ctx.single(kotlinAnalysis))
+        }
     }
 
     val psiToDocumentableTranslator by extending {
-        CoreExtensions.sourceToDocumentableTranslator with DefaultPsiToDocumentableTranslator
+        CoreExtensions.sourceToDocumentableTranslator providing { ctx ->
+            DefaultPsiToDocumentableTranslator(ctx.single(kotlinAnalysis))
+        }
     }
 
     val documentableMerger by extending(isFallback = true) {
@@ -69,7 +78,9 @@ class DokkaBase : DokkaPlugin() {
     }
 
     val modulesAndPackagesDocumentation by extending(isFallback = true) {
-        CoreExtensions.preMergeDocumentableTransformer providing ::ModuleAndPackageDocumentationTransformer
+        CoreExtensions.preMergeDocumentableTransformer providing { ctx ->
+            ModuleAndPackageDocumentationTransformer(ctx, ctx.single(kotlinAnalysis))
+        }
     }
 
     val kotlinSignatureProvider by extending(isFallback = true) {
@@ -124,6 +135,10 @@ class DokkaBase : DokkaPlugin() {
         CoreExtensions.renderer providing ::HtmlRenderer applyIf { format == "html" }
     }
 
+    val defaultKotlinAnalysis by extending(isFallback = true) {
+        kotlinAnalysis providing { ctx -> KotlinAnalysis(ctx) }
+    }
+
     val locationProvider by extending(isFallback = true) {
         locationProviderFactory providing ::DefaultLocationProviderFactory
     }
diff --git a/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt b/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
index ea1d8510..cdaa0274 100644
--- a/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
+++ b/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
@@ -9,7 +9,7 @@ import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.doc.P
 import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.parsers.MarkdownParser
+import org.jetbrains.dokka.base.parsers.MarkdownParser
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.querySingle
 import org.jetbrains.dokka.transformers.pages.PageCreator
diff --git a/plugins/base/src/main/kotlin/parsers/HtmlParser.kt b/plugins/base/src/main/kotlin/parsers/HtmlParser.kt
new file mode 100644
index 00000000..ece3cf24
--- /dev/null
+++ b/plugins/base/src/main/kotlin/parsers/HtmlParser.kt
@@ -0,0 +1,89 @@
+package org.jetbrains.dokka.base.parsers
+
+import org.jetbrains.dokka.model.doc.*
+import org.jetbrains.dokka.base.parsers.factories.DocTagsFromStringFactory
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Node
+import org.jsoup.select.NodeFilter
+import org.jsoup.select.NodeTraversor
+
+class HtmlParser : Parser() {
+
+    inner class NodeFilterImpl : NodeFilter {
+
+        private val nodesCache: MutableMap<Int, MutableList<DocTag>> = mutableMapOf()
+        private var currentDepth = 0
+
+        fun collect(): DocTag = nodesCache[currentDepth]!![0]
+
+        override fun tail(node: Node?, depth: Int): NodeFilter.FilterResult {
+            val nodeName = node!!.nodeName()
+            val nodeAttributes = node.attributes()
+
+            if(nodeName in listOf("#document", "html", "head"))
+                return NodeFilter.FilterResult.CONTINUE
+
+            val body: String
+            val params: Map<String, String>
+
+
+            if(nodeName != "#text") {
+                body = ""
+                params = nodeAttributes.map { it.key to it.value }.toMap()
+            } else {
+                body = nodeAttributes["#text"]
+                params = emptyMap()
+            }
+
+            val docNode = if(depth < currentDepth) {
+                DocTagsFromStringFactory.getInstance(nodeName, nodesCache.getOrDefault(currentDepth, mutableListOf()).toList(), params, body).also {
+                    nodesCache[currentDepth] = mutableListOf()
+                    currentDepth = depth
+                }
+            } else {
+                DocTagsFromStringFactory.getInstance(nodeName, emptyList(), params, body)
+            }
+
+            nodesCache.getOrDefault(depth, mutableListOf()) += docNode
+            return NodeFilter.FilterResult.CONTINUE
+        }
+
+        override fun head(node: Node?, depth: Int): NodeFilter.FilterResult {
+
+            val nodeName = node!!.nodeName()
+
+            if(currentDepth < depth) {
+                currentDepth = depth
+                nodesCache[currentDepth] = mutableListOf()
+            }
+
+            if(nodeName in listOf("#document", "html", "head"))
+                return NodeFilter.FilterResult.CONTINUE
+
+            return NodeFilter.FilterResult.CONTINUE
+        }
+    }
+
+
+    private fun htmlToDocNode(string: String): DocTag {
+        val document = Jsoup.parse(string)
+        val nodeFilterImpl = NodeFilterImpl()
+        NodeTraversor.filter(nodeFilterImpl, document.root())
+        return nodeFilterImpl.collect()
+    }
+
+    private fun replaceLinksWithHrefs(javadoc: String): String = Regex("\\{@link .*?}").replace(javadoc) {
+        val split = it.value.dropLast(1).split(" ")
+        if(split.size !in listOf(2, 3))
+            return@replace it.value
+        if(split.size == 3)
+            return@replace "<documentationlink href=\"${split[1]}\">${split[2]}</documentationlink>"
+        else
+            return@replace "<documentationlink href=\"${split[1]}\">${split[1]}</documentationlink>"
+    }
+
+    override fun parseStringToDocNode(extractedString: String) = htmlToDocNode(extractedString)
+    override fun preparse(text: String) = replaceLinksWithHrefs(text)
+}
+
+
diff --git a/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt b/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
new file mode 100644
index 00000000..6075ef73
--- /dev/null
+++ b/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
@@ -0,0 +1,419 @@
+package org.jetbrains.dokka.base.parsers
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.dokka.model.doc.*
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.intellij.markdown.ast.ASTNode
+import org.intellij.markdown.ast.CompositeASTNode
+import org.intellij.markdown.ast.LeafASTNode
+import org.intellij.markdown.ast.impl.ListItemCompositeNode
+import org.intellij.markdown.flavours.gfm.GFMElementTypes
+import org.intellij.markdown.flavours.gfm.GFMFlavourDescriptor
+import org.intellij.markdown.flavours.gfm.GFMTokenTypes
+import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+import org.jetbrains.dokka.analysis.from
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.base.parsers.factories.DocTagsFromIElementFactory
+import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
+import org.jetbrains.kotlin.kdoc.parser.KDocKnownTag
+import org.jetbrains.kotlin.kdoc.psi.impl.KDocSection
+import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
+import java.net.MalformedURLException
+import org.intellij.markdown.parser.MarkdownParser as IntellijMarkdownParser
+
+class MarkdownParser(
+    private val resolutionFacade: DokkaResolutionFacade? = null,
+    private val declarationDescriptor: DeclarationDescriptor? = null,
+    private val logger: DokkaLogger
+) : Parser() {
+
+    inner class MarkdownVisitor(val text: String, val destinationLinksMap: Map<String, String>) {
+
+        private fun headersHandler(node: ASTNode): DocTag =
+            DocTagsFromIElementFactory.getInstance(
+                node.type,
+                visitNode(node.children.find { it.type == MarkdownTokenTypes.ATX_CONTENT }
+                    ?: throw IllegalStateException("Wrong AST Tree. ATX Header does not contain expected content")).children
+            )
+
+        private fun horizontalRulesHandler(node: ASTNode): DocTag =
+            DocTagsFromIElementFactory.getInstance(MarkdownTokenTypes.HORIZONTAL_RULE)
+
+        private fun emphasisHandler(node: ASTNode): DocTag =
+            DocTagsFromIElementFactory.getInstance(
+                node.type,
+                children = listOf(visitNode(node.children[node.children.size / 2]))
+            )
+
+        private fun blockquotesHandler(node: ASTNode): DocTag =
+            DocTagsFromIElementFactory.getInstance(
+                node.type, children = node.children
+                    .filterIsInstance<CompositeASTNode>()
+                    .evaluateChildren()
+            )
+
+        private fun listsHandler(node: ASTNode): DocTag {
+
+            val children = node.children.filterIsInstance<ListItemCompositeNode>().flatMap {
+                if (it.children.last().type in listOf(
+                        MarkdownElementTypes.ORDERED_LIST,
+                        MarkdownElementTypes.UNORDERED_LIST
+                    )
+                ) {
+                    val nestedList = it.children.last()
+                    (it.children as MutableList).removeAt(it.children.lastIndex)
+                    listOf(it, nestedList)
+                } else
+                    listOf(it)
+            }
+
+            return DocTagsFromIElementFactory.getInstance(
+                node.type,
+                children =
+                children
+                    .map {
+                        if (it.type == MarkdownElementTypes.LIST_ITEM)
+                            DocTagsFromIElementFactory.getInstance(
+                                it.type,
+                                children = it
+                                    .children
+                                    .filterIsInstance<CompositeASTNode>()
+                                    .evaluateChildren()
+                            )
+                        else
+                            visitNode(it)
+                    },
+                params =
+                if (node.type == MarkdownElementTypes.ORDERED_LIST) {
+                    val listNumberNode = node.children.first().children.first()
+                    mapOf(
+                        "start" to text.substring(
+                            listNumberNode.startOffset,
+                            listNumberNode.endOffset
+                        ).trim().dropLast(1)
+                    )
+                } else
+                    emptyMap()
+            )
+        }
+
+        private fun resolveDRI(mdLink: String): DRI? =
+            mdLink
+                .removePrefix("[")
+                .removeSuffix("]")
+                .let { link ->
+                    try {
+                        java.net.URL(link)
+                        null
+                    } catch (e: MalformedURLException) {
+                        try {
+                            if (resolutionFacade != null && declarationDescriptor != null) {
+                                resolveKDocLink(
+                                    resolutionFacade.resolveSession.bindingContext,
+                                    resolutionFacade,
+                                    declarationDescriptor,
+                                    null,
+                                    link.split('.')
+                                ).minBy { it is ClassDescriptor }?.let { DRI.from(it) }
+                            } else null
+                        } catch (e1: IllegalArgumentException) {
+                            null
+                        }
+                    }
+                }
+
+        private fun referenceLinksHandler(node: ASTNode): DocTag {
+            val linkLabel = node.children.find { it.type == MarkdownElementTypes.LINK_LABEL }
+                ?: throw IllegalStateException("Wrong AST Tree. Reference link does not contain expected content")
+            val linkText = node.children.findLast { it.type == MarkdownElementTypes.LINK_TEXT } ?: linkLabel
+
+            val linkKey = text.substring(linkLabel.startOffset, linkLabel.endOffset)
+
+            val link = destinationLinksMap[linkKey.toLowerCase()] ?: linkKey
+
+            return linksHandler(linkText, link)
+        }
+
+        private fun inlineLinksHandler(node: ASTNode): DocTag {
+            val linkText = node.children.find { it.type == MarkdownElementTypes.LINK_TEXT }
+                ?: throw IllegalStateException("Wrong AST Tree. Inline link does not contain expected content")
+            val linkDestination = node.children.find { it.type == MarkdownElementTypes.LINK_DESTINATION }
+                ?: throw IllegalStateException("Wrong AST Tree. Inline link does not contain expected content")
+            val linkTitle = node.children.find { it.type == MarkdownElementTypes.LINK_TITLE }
+
+            val link = text.substring(linkDestination.startOffset, linkDestination.endOffset)
+
+            return linksHandler(linkText, link, linkTitle)
+        }
+
+        private fun autoLinksHandler(node: ASTNode): DocTag {
+            val link = text.substring(node.startOffset + 1, node.endOffset - 1)
+
+            return linksHandler(node, link)
+        }
+
+        private fun linksHandler(linkText: ASTNode, link: String, linkTitle: ASTNode? = null): DocTag {
+            val dri: DRI? = resolveDRI(link)
+            val params = if (linkTitle == null)
+                mapOf("href" to link)
+            else
+                mapOf("href" to link, "title" to text.substring(linkTitle.startOffset + 1, linkTitle.endOffset - 1))
+
+            return DocTagsFromIElementFactory.getInstance(
+                MarkdownElementTypes.INLINE_LINK,
+                params = params,
+                children = linkText.children.drop(1).dropLast(1).evaluateChildren(),
+                dri = dri
+            )
+        }
+
+        private fun imagesHandler(node: ASTNode): DocTag {
+            val linkNode =
+                node.children.last().children.find { it.type == MarkdownElementTypes.LINK_LABEL }!!.children[1]
+            val link = text.substring(linkNode.startOffset, linkNode.endOffset)
+            val src = mapOf("src" to link)
+            return DocTagsFromIElementFactory.getInstance(
+                node.type,
+                params = src,
+                children = listOf(visitNode(node.children.last().children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!))
+            )
+        }
+
+        private fun codeSpansHandler(node: ASTNode): DocTag =
+            DocTagsFromIElementFactory.getInstance(
+                node.type,
+                children = listOf(
+                    DocTagsFromIElementFactory.getInstance(
+                        MarkdownTokenTypes.TEXT,
+                        body = text.substring(node.startOffset + 1, node.endOffset - 1).replace('\n', ' ').trimIndent()
+                    )
+
+                )
+            )
+
+        private fun codeFencesHandler(node: ASTNode): DocTag =
+            DocTagsFromIElementFactory.getInstance(
+                node.type,
+                children = node
+                    .children
+                    .dropWhile { it.type != MarkdownTokenTypes.CODE_FENCE_CONTENT }
+                    .dropLastWhile { it.type != MarkdownTokenTypes.CODE_FENCE_CONTENT }
+                    .map {
+                        if (it.type == MarkdownTokenTypes.EOL)
+                            LeafASTNode(MarkdownTokenTypes.HARD_LINE_BREAK, 0, 0)
+                        else
+                            it
+                    }.evaluateChildren(),
+                params = node
+                    .children
+                    .find { it.type == MarkdownTokenTypes.FENCE_LANG }
+                    ?.let { mapOf("lang" to text.substring(it.startOffset, it.endOffset)) }
+                    ?: emptyMap()
+            )
+
+        private fun codeBlocksHandler(node: ASTNode): DocTag =
+            DocTagsFromIElementFactory.getInstance(node.type, children = node.children.evaluateChildren())
+
+        private fun defaultHandler(node: ASTNode): DocTag =
+            DocTagsFromIElementFactory.getInstance(
+                MarkdownElementTypes.PARAGRAPH,
+                children = node.children.evaluateChildren()
+            )
+
+        fun visitNode(node: ASTNode): DocTag =
+            when (node.type) {
+                MarkdownElementTypes.ATX_1,
+                MarkdownElementTypes.ATX_2,
+                MarkdownElementTypes.ATX_3,
+                MarkdownElementTypes.ATX_4,
+                MarkdownElementTypes.ATX_5,
+                MarkdownElementTypes.ATX_6 -> headersHandler(node)
+                MarkdownTokenTypes.HORIZONTAL_RULE -> horizontalRulesHandler(node)
+                MarkdownElementTypes.STRONG,
+                MarkdownElementTypes.EMPH -> emphasisHandler(node)
+                MarkdownElementTypes.FULL_REFERENCE_LINK,
+                MarkdownElementTypes.SHORT_REFERENCE_LINK -> referenceLinksHandler(node)
+                MarkdownElementTypes.INLINE_LINK -> inlineLinksHandler(node)
+                MarkdownElementTypes.AUTOLINK -> autoLinksHandler(node)
+                MarkdownElementTypes.BLOCK_QUOTE -> blockquotesHandler(node)
+                MarkdownElementTypes.UNORDERED_LIST,
+                MarkdownElementTypes.ORDERED_LIST -> listsHandler(node)
+                MarkdownElementTypes.CODE_BLOCK -> codeBlocksHandler(node)
+                MarkdownElementTypes.CODE_FENCE -> codeFencesHandler(node)
+                MarkdownElementTypes.CODE_SPAN -> codeSpansHandler(node)
+                MarkdownElementTypes.IMAGE -> imagesHandler(node)
+                MarkdownTokenTypes.HARD_LINE_BREAK -> DocTagsFromIElementFactory.getInstance(node.type)
+                MarkdownTokenTypes.CODE_FENCE_CONTENT,
+                MarkdownTokenTypes.CODE_LINE,
+                MarkdownTokenTypes.TEXT -> DocTagsFromIElementFactory.getInstance(
+                    MarkdownTokenTypes.TEXT,
+                    body = text
+                        .substring(node.startOffset, node.endOffset).transform()
+                )
+                MarkdownElementTypes.MARKDOWN_FILE -> if (node.children.size == 1) visitNode(node.children.first()) else defaultHandler(
+                    node
+                )
+                GFMElementTypes.STRIKETHROUGH -> DocTagsFromIElementFactory.getInstance(
+                    GFMElementTypes.STRIKETHROUGH,
+                    body = text
+                        .substring(node.startOffset, node.endOffset).transform()
+                )
+                GFMElementTypes.TABLE -> DocTagsFromIElementFactory.getInstance(
+                    GFMElementTypes.TABLE,
+                    children = node.children.filterTabSeparators().evaluateChildren()
+                )
+                GFMElementTypes.HEADER -> DocTagsFromIElementFactory.getInstance(
+                    GFMElementTypes.HEADER,
+                    children = node.children.filterTabSeparators().evaluateChildren()
+                )
+                GFMElementTypes.ROW -> DocTagsFromIElementFactory.getInstance(
+                    GFMElementTypes.ROW,
+                    children = node.children.filterTabSeparators().evaluateChildren()
+                )
+                else -> defaultHandler(node)
+            }
+
+        private fun List<ASTNode>.filterTabSeparators() =
+            this.filterNot { it.type == GFMTokenTypes.TABLE_SEPARATOR }
+
+        private fun List<ASTNode>.evaluateChildren(): List<DocTag> =
+            this.removeUselessTokens().mergeLeafASTNodes().map { visitNode(it) }
+
+        private fun List<ASTNode>.removeUselessTokens(): List<ASTNode> =
+            this.filterIndexed { index, node ->
+                !(node.type == MarkdownElementTypes.LINK_DEFINITION || (
+                        node.type == MarkdownTokenTypes.EOL &&
+                                this.getOrNull(index - 1)?.type == MarkdownTokenTypes.HARD_LINE_BREAK
+                        ))
+            }
+
+        private val notLeafNodes = listOf(MarkdownTokenTypes.HORIZONTAL_RULE, MarkdownTokenTypes.HARD_LINE_BREAK)
+
+        private fun List<ASTNode>.isNotLeaf(index: Int): Boolean =
+            if (index in 0..this.lastIndex)
+                (this[index] is CompositeASTNode) || this[index].type in notLeafNodes
+            else
+                false
+
+        private fun List<ASTNode>.mergeLeafASTNodes(): List<ASTNode> {
+            val children: MutableList<ASTNode> = mutableListOf()
+            var index = 0
+            while (index <= this.lastIndex) {
+                if (this.isNotLeaf(index)) {
+                    children += this[index]
+                } else {
+                    val startOffset = this[index].startOffset
+                    while (index < this.lastIndex) {
+                        if (this.isNotLeaf(index + 1) || this[index + 1].startOffset != this[index].endOffset) {
+                            val endOffset = this[index].endOffset
+                            if (text.substring(startOffset, endOffset).transform().trim().isNotEmpty())
+                                children += LeafASTNode(MarkdownTokenTypes.TEXT, startOffset, endOffset)
+                            break
+                        }
+                        index++
+                    }
+                    if (index == this.lastIndex) {
+                        val endOffset = this[index].endOffset
+                        if (text.substring(startOffset, endOffset).transform().trim().isNotEmpty())
+                            children += LeafASTNode(MarkdownTokenTypes.TEXT, startOffset, endOffset)
+                    }
+                }
+                index++
+            }
+            return children
+        }
+
+        private fun String.transform() = this
+            .replace(Regex("\n\n+"), "")        // Squashing new lines between paragraphs
+            .replace(Regex("\n"), " ")
+            .replace(Regex(" >+ +"), " ")      // Replacement used in blockquotes, get rid of garbage
+    }
+
+
+    private fun getAllDestinationLinks(text: String, node: ASTNode): List<Pair<String, String>> =
+        node.children
+            .filter { it.type == MarkdownElementTypes.LINK_DEFINITION }
+            .map {
+                text.substring(it.children[0].startOffset, it.children[0].endOffset).toLowerCase() to
+                        text.substring(it.children[2].startOffset, it.children[2].endOffset)
+            } +
+                node.children.filterIsInstance<CompositeASTNode>().flatMap { getAllDestinationLinks(text, it) }
+
+
+    private fun markdownToDocNode(text: String): DocTag {
+
+        val flavourDescriptor = GFMFlavourDescriptor()
+        val markdownAstRoot: ASTNode = IntellijMarkdownParser(flavourDescriptor).buildMarkdownTreeFromString(text)
+
+        return MarkdownVisitor(text, getAllDestinationLinks(text, markdownAstRoot).toMap()).visitNode(markdownAstRoot)
+    }
+
+    override fun parseStringToDocNode(extractedString: String) = markdownToDocNode(extractedString)
+    override fun preparse(text: String) = text
+
+    private fun findParent(kDoc: PsiElement): PsiElement =
+        if (kDoc is KDocSection) findParent(kDoc.parent) else kDoc
+
+    private fun getAllKDocTags(kDocImpl: PsiElement): List<KDocTag> =
+        kDocImpl.children.filterIsInstance<KDocTag>().filterNot { it is KDocSection } + kDocImpl.children.flatMap {
+            getAllKDocTags(
+                it
+            )
+        }
+
+    fun parseFromKDocTag(kDocTag: KDocTag?): DocumentationNode {
+        return if (kDocTag == null)
+            DocumentationNode(emptyList())
+        else
+            DocumentationNode(
+                (listOf(kDocTag) + getAllKDocTags(findParent(kDocTag))).map {
+                    when (it.knownTag) {
+                        null -> if (it.name == null) Description(parseStringToDocNode(it.getContent())) else CustomTagWrapper(
+                            parseStringToDocNode(it.getContent()),
+                            it.name!!
+                        )
+                        KDocKnownTag.AUTHOR -> Author(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.THROWS -> Throws(
+                            parseStringToDocNode(it.getContent()),
+                            it.getSubjectName().orEmpty()
+                        )
+                        KDocKnownTag.EXCEPTION -> Throws(
+                            parseStringToDocNode(it.getContent()),
+                            it.getSubjectName().orEmpty()
+                        )
+                        KDocKnownTag.PARAM -> Param(
+                            parseStringToDocNode(it.getContent()),
+                            it.getSubjectName().orEmpty()
+                        )
+                        KDocKnownTag.RECEIVER -> Receiver(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.RETURN -> Return(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.SEE -> See(
+                            parseStringToDocNode(it.getContent()),
+                            it.getSubjectName().orEmpty(),
+                            parseStringToDocNode("[${it.getSubjectName()}]")
+                                .let {
+                                    val link = it.children[0]
+                                    if (link is DocumentationLink) link.dri
+                                    else null
+                                }
+                        )
+                        KDocKnownTag.SINCE -> Since(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.CONSTRUCTOR -> Constructor(parseStringToDocNode(it.getContent()))
+                        KDocKnownTag.PROPERTY -> Property(
+                            parseStringToDocNode(it.getContent()),
+                            it.getSubjectName().orEmpty()
+                        )
+                        KDocKnownTag.SAMPLE -> Sample(
+                            parseStringToDocNode(it.getContent()),
+                            it.getSubjectName().orEmpty()
+                        )
+                        KDocKnownTag.SUPPRESS -> Suppress(parseStringToDocNode(it.getContent()))
+                    }
+                }
+            )
+    }
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/parsers/Parser.kt b/plugins/base/src/main/kotlin/parsers/Parser.kt
new file mode 100644
index 00000000..1dd0c34a
--- /dev/null
+++ b/plugins/base/src/main/kotlin/parsers/Parser.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.dokka.base.parsers
+
+import org.jetbrains.dokka.model.doc.*
+
+abstract class Parser {
+
+    abstract fun parseStringToDocNode(extractedString: String): DocTag
+    abstract fun preparse(text: String): String
+
+    fun parse(text: String): DocumentationNode {
+
+        val list = jkdocToListOfPairs(preparse(text))
+
+        val mappedList: List<TagWrapper> = list.map {
+            when(it.first) {
+                "description"         -> Description(parseStringToDocNode(it.second))
+                "author"              -> Author(parseStringToDocNode(it.second))
+                "version"             -> Version(parseStringToDocNode(it.second))
+                "since"               -> Since(parseStringToDocNode(it.second))
+                "see"                 -> See(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '), null)
+                "param"               -> Param(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "property"            -> Property(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "return"              -> Return(parseStringToDocNode(it.second))
+                "constructor"         -> Constructor(parseStringToDocNode(it.second))
+                "receiver"            -> Receiver(parseStringToDocNode(it.second))
+                "throws", "exception" -> Throws(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "deprecated"          -> Deprecated(parseStringToDocNode(it.second))
+                "sample"              -> Sample(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
+                "suppress"            -> Suppress(parseStringToDocNode(it.second))
+                else                  -> CustomTagWrapper(parseStringToDocNode(it.second), it.first)
+            }
+        }
+        return DocumentationNode(mappedList)
+    }
+
+    private fun jkdocToListOfPairs(javadoc: String): List<Pair<String, String>> =
+        "description $javadoc"
+            .split("\n@")
+            .map {
+                it.substringBefore(' ') to it.substringAfter(' ')
+            }
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt b/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
new file mode 100644
index 00000000..e81eb513
--- /dev/null
+++ b/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
@@ -0,0 +1,43 @@
+package org.jetbrains.dokka.base.parsers.factories
+
+import org.jetbrains.dokka.model.doc.*
+import org.intellij.markdown.IElementType
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.intellij.markdown.flavours.gfm.GFMElementTypes
+import org.jetbrains.dokka.links.DRI
+import java.lang.NullPointerException
+
+object DocTagsFromIElementFactory {
+    fun getInstance(type: IElementType, children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
+        when(type) {
+            MarkdownElementTypes.SHORT_REFERENCE_LINK,
+            MarkdownElementTypes.FULL_REFERENCE_LINK,
+            MarkdownElementTypes.INLINE_LINK            -> if(dri == null) A(children, params) else DocumentationLink(dri, children, params)
+            MarkdownElementTypes.STRONG                 -> B(children, params)
+            MarkdownElementTypes.BLOCK_QUOTE            -> BlockQuote(children, params)
+            MarkdownElementTypes.CODE_SPAN,
+            MarkdownElementTypes.CODE_BLOCK,
+            MarkdownElementTypes.CODE_FENCE             -> Code(children, params)
+            MarkdownElementTypes.ATX_1                  -> H1(children, params)
+            MarkdownElementTypes.ATX_2                  -> H2(children, params)
+            MarkdownElementTypes.ATX_3                  -> H3(children, params)
+            MarkdownElementTypes.ATX_4                  -> H4(children, params)
+            MarkdownElementTypes.ATX_5                  -> H5(children, params)
+            MarkdownElementTypes.ATX_6                  -> H6(children, params)
+            MarkdownElementTypes.EMPH                   -> I(children, params)
+            MarkdownElementTypes.IMAGE                  -> Img(children, params)
+            MarkdownElementTypes.LIST_ITEM              -> Li(children, params)
+            MarkdownElementTypes.ORDERED_LIST           -> Ol(children, params)
+            MarkdownElementTypes.UNORDERED_LIST         -> Ul(children, params)
+            MarkdownElementTypes.PARAGRAPH              -> P(children, params)
+            MarkdownTokenTypes.TEXT                     -> Text(body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"), children, params )
+            MarkdownTokenTypes.HORIZONTAL_RULE          -> HorizontalRule
+            MarkdownTokenTypes.HARD_LINE_BREAK          -> Br
+            GFMElementTypes.STRIKETHROUGH               -> Strikethrough(children, params)
+            GFMElementTypes.TABLE                       -> Table(children, params)
+            GFMElementTypes.HEADER                      -> Th(children, params)
+            GFMElementTypes.ROW                         -> Tr(children, params)
+            else                                        -> CustomDocTag(children, params)
+        }
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt b/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt
new file mode 100644
index 00000000..de7c3cad
--- /dev/null
+++ b/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt
@@ -0,0 +1,77 @@
+package org.jetbrains.dokka.base.parsers.factories
+
+import org.jetbrains.dokka.model.doc.*
+import org.jetbrains.dokka.links.DRI
+import java.lang.NullPointerException
+
+object DocTagsFromStringFactory {
+    fun getInstance(name: String, children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
+        when(name) {
+            "a" -> A(children, params)
+            "big" -> Big(children, params)
+            "b" -> B(children, params)
+            "blockquote" -> BlockQuote(children, params)
+            "br" -> Br
+            "cite" -> Cite(children, params)
+            "code" -> Code(children, params)
+            "dd" -> Dd(children, params)
+            "dfn" -> Dfn(children, params)
+            "dir" -> Dir(children, params)
+            "div" -> Div(children, params)
+            "dl" -> Dl(children, params)
+            "dt" -> Dt(children, params)
+            "Em" -> Em(children, params)
+            "font" -> Font(children, params)
+            "footer" -> Footer(children, params)
+            "frame" -> Frame(children, params)
+            "frameset" -> FrameSet(children, params)
+            "h1" -> H1(children, params)
+            "h2" -> H2(children, params)
+            "h3" -> H3(children, params)
+            "h4" -> H4(children, params)
+            "h5" -> H5(children, params)
+            "h6" -> H6(children, params)
+            "head" -> Head(children, params)
+            "header" -> Header(children, params)
+            "html" -> Html(children, params)
+            "i" -> I(children, params)
+            "iframe" -> IFrame(children, params)
+            "img" -> Img(children, params)
+            "input" -> Input(children, params)
+            "li" -> Li(children, params)
+            "link" -> Link(children, params)
+            "listing" -> Listing(children, params)
+            "main" -> Main(children, params)
+            "menu" -> Menu(children, params)
+            "meta" -> Meta(children, params)
+            "nav" -> Nav(children, params)
+            "noframes" -> NoFrames(children, params)
+            "noscript" -> NoScript(children, params)
+            "ol" -> Ol(children, params)
+            "p" -> P(children, params)
+            "pre" -> Pre(children, params)
+            "script" -> Script(children, params)
+            "section" -> Section(children, params)
+            "small" -> Small(children, params)
+            "span" -> Span(children, params)
+            "strong" -> Strong(children, params)
+            "sub" -> Sub(children, params)
+            "sup" -> Sup(children, params)
+            "table" -> Table(children, params)
+            "#text" -> Text(body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"), children, params)
+            "tBody" -> TBody(children, params)
+            "td" -> Td(children, params)
+            "tFoot" -> TFoot(children, params)
+            "th" -> Th(children, params)
+            "tHead" -> THead(children, params)
+            "title" -> Title(children, params)
+            "tr" -> Tr(children, params)
+            "tt" -> Tt(children, params)
+            "u" -> U(children, params)
+            "ul" -> Ul(children, params)
+            "var" -> Var(children, params)
+            "documentationlink" -> DocumentationLink(dri ?: throw NullPointerException("DRI cannot be passed null while constructing documentation link!"), children, params)
+            "hr" -> HorizontalRule
+            else -> CustomDocTag(children, params)
+        }
+}
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
index 2aab6018..63232793 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
@@ -1,10 +1,13 @@
 package org.jetbrains.dokka.base.transformers.documentables
 
+import org.jetbrains.dokka.analysis.EnvironmentAndFacade
+import org.jetbrains.dokka.analysis.KotlinAnalysis
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.sourceSet
-import org.jetbrains.dokka.parsers.MarkdownParser
+import org.jetbrains.dokka.base.parsers.MarkdownParser
+import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 import org.jetbrains.kotlin.name.FqName
@@ -12,9 +15,12 @@ import java.nio.file.Files
 import java.nio.file.Paths
 
 
-internal class ModuleAndPackageDocumentationTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
+internal class ModuleAndPackageDocumentationTransformer(
+    private val context: DokkaContext,
+    private val kotlinAnalysis: KotlinAnalysis
+) : PreMergeDocumentableTransformer {
 
-    override fun invoke(original: List<DModule>): List<DModule> {
+    override fun invoke(modules: List<DModule>): List<DModule> {
 
         val modulesAndPackagesDocumentation =
             context.configuration.passesConfigurations
@@ -47,13 +53,12 @@ internal class ModuleAndPackageDocumentationTransformer(val context: DokkaContex
                                 }
                 }.toMap()
 
-        return original.map { module ->
+        return modules.map { module ->
 
             val moduleDocumentation =
                 module.sourceSets.mapNotNull { pd ->
                     val doc = modulesAndPackagesDocumentation[Pair(module.name, pd)]
-                    val facade = context.platforms[pd]?.facade
-                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetID}") }
+                    val facade = kotlinAnalysis[pd].facade
                     try {
                         doc?.get("Module")?.get(module.name)?.run {
                             pd to MarkdownParser(
@@ -71,8 +76,7 @@ internal class ModuleAndPackageDocumentationTransformer(val context: DokkaContex
             val packagesDocumentation = module.packages.map {
                 it.name to it.sourceSets.mapNotNull { pd ->
                     val doc = modulesAndPackagesDocumentation[Pair(module.name, pd)]
-                    val facade = context.platforms[pd]?.facade
-                        ?: return@mapNotNull null.also { context.logger.warn("Could not find platform data for ${pd.moduleName}/${pd.sourceSetID}") }
+                    val facade = kotlinAnalysis[pd].facade
                     val descriptor = facade.moduleDescriptor.getPackage(FqName(it.name.let { if(it == "[JS root]") "" else it }))
                     doc?.get("Package")?.get(it.name)?.run {
                         pd to MarkdownParser(
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
index 7d475571..0b47345d 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
@@ -2,6 +2,7 @@ package org.jetbrains.dokka.base.transformers.documentables
 
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.DokkaConfiguration.PassConfiguration
+import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer
diff --git a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
index 57655a9d..0d133a65 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
@@ -1,11 +1,11 @@
 package org.jetbrains.dokka.base.transformers.pages.samples
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.dokka.DokkaGenerator
-import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.analysis.AnalysisEnvironment
+import org.jetbrains.dokka.analysis.DokkaMessageCollector
 import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+import org.jetbrains.dokka.analysis.EnvironmentAndFacade
 import org.jetbrains.dokka.base.renderers.platforms
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.SourceSetData
@@ -41,7 +41,7 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
     }
 
     private fun setUpAnalysis(context: DokkaContext) = context.configuration.passesConfigurations.map {
-        context.sourceSet(it) to AnalysisEnvironment(DokkaGenerator.DokkaMessageCollector(context.logger), it.analysisPlatform).run {
+        context.sourceSet(it) to AnalysisEnvironment(DokkaMessageCollector(context.logger), it.analysisPlatform).run {
             if (analysisPlatform == Platform.jvm) {
                 addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
             }
@@ -57,11 +57,16 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         }
     }.toMap()
 
-    private fun ContentNode.addSample(contentPage: ContentPage, platform: SourceSetData, fqName: String, analysis: Map<SourceSetData, EnvironmentAndFacade>): ContentNode {
-        val facade = analysis[platform]?.facade ?:
-            return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleName}")}
-        val psiElement = fqNameToPsiElement(facade, fqName) ?:
-            return this.also { context.logger.warn("Cannot find PsiElement corresponding to $fqName") }
+    private fun ContentNode.addSample(
+        contentPage: ContentPage,
+        platform: SourceSetData,
+        fqName: String,
+        analysis: Map<SourceSetData, EnvironmentAndFacade>
+    ): ContentNode {
+        val facade = analysis[platform]?.facade
+            ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleName}") }
+        val psiElement = fqNameToPsiElement(facade, fqName)
+            ?: return this.also { context.logger.warn("Cannot find PsiElement corresponding to $fqName") }
         val imports = processImports(psiElement) // TODO: Process somehow imports. Maybe just attach them at the top of each body
         val body = processBody(psiElement)
         val node = contentCode(contentPage.platforms(), contentPage.dri, body, "kotlin")
@@ -70,10 +75,14 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
     }
 
     private fun ContentNode.dfs(fqName: String, node: ContentCode): ContentNode {
-        return when(this) {
+        return when (this) {
             is ContentHeader -> copy(children.map { it.dfs(fqName, node) })
             is ContentDivergentGroup -> copy(children.map { it.dfs(fqName, node) } as List<ContentDivergentInstance>)
-            is ContentDivergentInstance -> copy(before.let { it?.dfs(fqName, node) }, divergent.let { it.dfs(fqName, node) }, after.let { it?.dfs(fqName, node) })
+            is ContentDivergentInstance -> copy(
+                before.let { it?.dfs(fqName, node) },
+                divergent.dfs(fqName, node),
+                after.let { it?.dfs(fqName, node) }
+            )
             is ContentCode -> copy(children.map { it.dfs(fqName, node) })
             is ContentDRILink -> copy(children.map { it.dfs(fqName, node) })
             is ContentResolvedLink -> copy(children.map { it.dfs(fqName, node) })
@@ -90,10 +99,14 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
 
     private fun fqNameToPsiElement(resolutionFacade: DokkaResolutionFacade, functionName: String): PsiElement? {
         val packageName = functionName.takeWhile { it != '.' }
-        val descriptor = resolutionFacade.resolveSession.getPackageFragment(FqName(packageName)) ?:
-            return null.also { context.logger.warn("Cannot find descriptor for package $packageName") }
-        val symbol = resolveKDocSampleLink(BindingContext.EMPTY, resolutionFacade, descriptor, functionName.split(".")).firstOrNull() ?:
-            return null.also { context.logger.warn("Unresolved function $functionName in @sample") }
+        val descriptor = resolutionFacade.resolveSession.getPackageFragment(FqName(packageName))
+            ?: return null.also { context.logger.warn("Cannot find descriptor for package $packageName") }
+        val symbol = resolveKDocSampleLink(
+            BindingContext.EMPTY,
+            resolutionFacade,
+            descriptor,
+            functionName.split(".")
+        ).firstOrNull() ?: return null.also { context.logger.warn("Unresolved function $functionName in @sample") }
         return DescriptorToSourceUtils.descriptorToDeclaration(symbol)
     }
 
diff --git a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
index 8113d277..7603c80b 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
@@ -3,11 +3,11 @@ package org.jetbrains.dokka.base.transformers.pages.sourcelinks
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
+import org.jetbrains.dokka.analysis.PsiDocumentableSource
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
-import org.jetbrains.dokka.model.DescriptorDocumentableSource
 import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.DocumentableSource
-import org.jetbrains.dokka.model.PsiDocumentableSource
 import org.jetbrains.dokka.model.WithExpectActual
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index 49d8ae0f..cefea4ec 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.base.translators.descriptors
 
-import org.jetbrains.dokka.analysis.DokkaResolutionFacade
+import org.jetbrains.dokka.analysis.*
 import org.jetbrains.dokka.links.*
 import org.jetbrains.dokka.links.Callable
 import org.jetbrains.dokka.model.*
@@ -8,7 +8,7 @@ import org.jetbrains.dokka.model.Nullable
 import org.jetbrains.dokka.model.TypeConstructor
 import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.parsers.MarkdownParser
+import org.jetbrains.dokka.base.parsers.MarkdownParser
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.sources.SourceToDocumentableTranslator
 import org.jetbrains.dokka.utilities.DokkaLogger
@@ -52,18 +52,19 @@ import org.jetbrains.kotlin.resolve.constants.EnumValue as ConstantsEnumValue
 import org.jetbrains.kotlin.resolve.constants.KClassValue as ConstantsKtClassValue
 import kotlin.IllegalArgumentException
 
-object DefaultDescriptorToDocumentableTranslator : SourceToDocumentableTranslator {
+class DefaultDescriptorToDocumentableTranslator(
+    private val kotlinAnalysis: KotlinAnalysis
+) : SourceToDocumentableTranslator {
 
     override fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule {
-
-        val (environment, facade) = context.platforms.getValue(sourceSet)
+        val (environment, facade) = kotlinAnalysis[sourceSet]
         val packageFragments = environment.getSourceFiles().asSequence()
             .map { it.packageFqName }
             .distinct()
             .mapNotNull { facade.resolveSession.getPackageFragment(it) }
             .toList()
 
-        return DokkaDescriptorVisitor(sourceSet, context.platforms.getValue(sourceSet).facade, context.logger).run {
+        return DokkaDescriptorVisitor(sourceSet, kotlinAnalysis[sourceSet].facade, context.logger).run {
             packageFragments.mapNotNull { it.safeAs<PackageFragmentDescriptor>() }.map {
                 visitPackageFragmentDescriptor(
                     it,
diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
index a5117b09..e71d936a 100644
--- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
@@ -7,6 +7,10 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.*
 import com.intellij.psi.impl.source.PsiClassReferenceType
 import com.intellij.psi.impl.source.PsiImmediateClassType
+import org.jetbrains.dokka.analysis.KotlinAnalysis
+import org.jetbrains.dokka.analysis.PsiDocumentableSource
+import org.jetbrains.dokka.analysis.from
+import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.nextTarget
 import org.jetbrains.dokka.links.withClass
@@ -17,6 +21,7 @@ import org.jetbrains.dokka.model.doc.Param
 import org.jetbrains.dokka.model.doc.Text
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.transformers.sources.SourceToDocumentableTranslator
 import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
@@ -33,15 +38,17 @@ import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import java.io.File
 
-object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
+class DefaultPsiToDocumentableTranslator(
+    private val kotlinAnalysis: KotlinAnalysis
+) : SourceToDocumentableTranslator {
 
-    override fun invoke(sourceSetData: SourceSetData, context: DokkaContext): DModule {
+    override fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule {
 
         fun isFileInSourceRoots(file: File): Boolean {
-            return sourceSetData.sourceRoots.any { root -> file.path.startsWith(File(root.path).absolutePath) }
+            return sourceSet.sourceRoots.any { root -> file.path.startsWith(File(root.path).absolutePath) }
         }
 
-        val (environment, _) = context.platforms.getValue(sourceSetData)
+        val (environment, _) = kotlinAnalysis[sourceSet]
 
         val sourceRoots = environment.configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
             ?.filterIsInstance<JavaSourceRoot>()
@@ -59,11 +66,11 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
 
         val docParser =
             DokkaPsiParser(
-                sourceSetData,
+                sourceSet,
                 context.logger
             )
         return DModule(
-            sourceSetData.moduleName,
+            sourceSet.moduleName,
             psiFiles.mapNotNull { it.safeAs<PsiJavaFile>() }.groupBy { it.packageName }.map { (packageName, psiFiles) ->
                 val dri = DRI(packageName = packageName)
                 DPackage(
@@ -76,12 +83,12 @@ object DefaultPsiToDocumentableTranslator : SourceToDocumentableTranslator {
                     emptyList(),
                     emptyMap(),
                     null,
-                    setOf(sourceSetData)
+                    setOf(sourceSet)
                 )
             },
             emptyMap(),
             null,
-            setOf(sourceSetData)
+            setOf(sourceSet)
         )
     }
 
diff --git a/plugins/base/src/main/kotlin/translators/psi/JavadocParser.kt b/plugins/base/src/main/kotlin/translators/psi/JavadocParser.kt
index d8130974..7119ba68 100644
--- a/plugins/base/src/main/kotlin/translators/psi/JavadocParser.kt
+++ b/plugins/base/src/main/kotlin/translators/psi/JavadocParser.kt
@@ -6,6 +6,7 @@ import com.intellij.psi.impl.source.tree.JavaDocElementType
 import com.intellij.psi.impl.source.tree.LeafPsiElement
 import com.intellij.psi.javadoc.*
 import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.dokka.analysis.from
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.model.doc.Deprecated
diff --git a/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt b/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
index 2c805110..d548b75b 100644
--- a/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
+++ b/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
@@ -28,7 +28,7 @@ class FailOnWarningTest : AbstractCoreTest() {
                 |package sample
                 """.trimIndent(), configuration
             ) {
-                analysisSetupStage = {
+                pluginsSetupStage = {
                     logger.warn("Warning!")
                 }
             }
@@ -53,7 +53,7 @@ class FailOnWarningTest : AbstractCoreTest() {
                 |package sample
                 """.trimIndent(), configuration
             ) {
-                analysisSetupStage = {
+                pluginsSetupStage = {
                     logger.error("Error!")
                 }
             }
@@ -102,7 +102,7 @@ class FailOnWarningTest : AbstractCoreTest() {
                 |package sample
                 """.trimIndent(), configuration
         ) {
-            analysisSetupStage = {
+            pluginsSetupStage = {
                 logger.warn("Error!")
                 logger.error("Error!")
             }
diff --git a/plugins/build.gradle.kts b/plugins/build.gradle.kts
index d681cf2a..bb3b1a3d 100644
--- a/plugins/build.gradle.kts
+++ b/plugins/build.gradle.kts
@@ -6,8 +6,9 @@ subprojects {
 
     dependencies {
         compileOnly(project(":core"))
-//        compileOnly(project(":coreDependencies", configuration = "shadow")) // uncomment if IntelliJ does not recognize pacakges from IntelliJ
         implementation(kotlin("stdlib-jdk8"))
+        implementation(kotlin("stdlib"))
+        implementation(kotlin("reflect"))
 
         testImplementation(project(":testApi"))
         testImplementation("org.junit.jupiter:junit-jupiter:5.6.0")
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
index c148a440..becacd26 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
@@ -2,6 +2,9 @@ package javadoc.pages
 
 import com.intellij.psi.PsiClass
 import org.jetbrains.dokka.Platform
+import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
+import org.jetbrains.dokka.analysis.PsiDocumentableSource
+import org.jetbrains.dokka.analysis.from
 import org.jetbrains.dokka.base.renderers.platforms
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.*
diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
index 45e97945..905cb61b 100644
--- a/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
+++ b/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
@@ -66,4 +66,4 @@ class JavadocTest : AbstractCoreTest() {
 //            }
 //        }
 //    }
-}
\ No newline at end of file
+}
diff --git a/runners/cli/build.gradle.kts b/runners/cli/build.gradle.kts
index 6c3a4d7d..8c4955ca 100644
--- a/runners/cli/build.gradle.kts
+++ b/runners/cli/build.gradle.kts
@@ -12,6 +12,7 @@ dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-cli-jvm:0.2.1")
     implementation("com.google.code.gson:gson:2.8.5")
     implementation(project(":core"))
+    implementation(kotlin("stdlib"))
 }
 
 
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index f0df08e0..80971ae2 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -5,7 +5,7 @@ import kotlinx.cli.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
 import org.jetbrains.dokka.DokkaConfiguration.PassConfiguration.*
 import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jetbrains.kotlin.utils.addToStdlib.cast
+import org.jetbrains.dokka.utilities.cast
 import java.io.*
 import java.net.MalformedURLException
 import java.net.URL
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 b7961b6e..41d6e67a 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
@@ -3,6 +3,7 @@ package org.jetbrains.dokka.gradle
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
+import org.gradle.api.attributes.Usage
 import org.gradle.util.GradleVersion
 import java.io.File
 import java.io.InputStream
@@ -20,9 +21,8 @@ open class DokkaPlugin : Plugin<Project> {
         val pluginsConfiguration = project.configurations.create("dokkaPlugins").apply {
             dependencies.add(project.dependencies.create("org.jetbrains.dokka:dokka-base:${DokkaVersion.version}"))
             attributes.attribute(
-                    org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE,
-                    project.objects.named(org.gradle.api.attributes.Usage::class.java, "java-runtime")
-                )
+                Usage.USAGE_ATTRIBUTE, project.objects.named(Usage::class.java, "java-runtime")
+            )
             isCanBeConsumed = false
         }
         addDokkaTasks(project, dokkaRuntimeConfiguration, pluginsConfiguration, DokkaTask::class.java)
diff --git a/settings.gradle.kts b/settings.gradle.kts
index c813518d..bb91edc6 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,13 +1,15 @@
 rootProject.name = "dokka"
 
 include("core")
+include("core:dependencies")
 include("plugins:base:search-component")
-include("coreDependencies")
 include("testApi")
 include("test-tools")
 include("runners:gradle-plugin")
 include("runners:cli")
 include("runners:maven-plugin")
+include("kotlin-analysis")
+include("kotlin-analysis:dependencies")
 include("plugins:base")
 include("plugins:base:frontend")
 include("plugins:mathjax")
@@ -27,7 +29,7 @@ pluginManagement {
     }
 
     repositories {
-        maven(url="https://dl.bintray.com/kotlin/kotlin-dev/")
+        maven(url = "https://dl.bintray.com/kotlin/kotlin-dev/")
         mavenLocal()
         mavenCentral()
         jcenter()
diff --git a/test-tools/build.gradle.kts b/test-tools/build.gradle.kts
index 7fd8a879..a61787a8 100644
--- a/test-tools/build.gradle.kts
+++ b/test-tools/build.gradle.kts
@@ -1,5 +1,6 @@
 dependencies {
     implementation(project(":testApi"))
     implementation(kotlin("stdlib-jdk8"))
+    implementation(kotlin("reflect"))
     implementation("com.willowtreeapps.assertk:assertk-jvm:0.22")
 }
\ No newline at end of file
diff --git a/testApi/build.gradle.kts b/testApi/build.gradle.kts
index 43c984b5..c8b510a1 100644
--- a/testApi/build.gradle.kts
+++ b/testApi/build.gradle.kts
@@ -7,8 +7,10 @@ plugins {
 
 dependencies {
     api(project(":core"))
+    implementation(project(":kotlin-analysis"))
     implementation("junit:junit:4.13") // TODO: remove dependency to junit
     implementation(kotlin("stdlib"))
+    implementation(kotlin("reflect"))
 }
 
 val sourceJar by tasks.registering(Jar::class) {
diff --git a/testApi/src/main/kotlin/testApi/context/MockContext.kt b/testApi/src/main/kotlin/testApi/context/MockContext.kt
index 11520280..e3da5f68 100644
--- a/testApi/src/main/kotlin/testApi/context/MockContext.kt
+++ b/testApi/src/main/kotlin/testApi/context/MockContext.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.testApi.context
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.model.SourceSetCache
 import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -16,7 +15,6 @@ import kotlin.reflect.full.memberProperties
 class MockContext(
     vararg extensions: Pair<ExtensionPoint<*>, (DokkaContext) -> Any>,
     private val testConfiguration: DokkaConfiguration? = null,
-    private val testSourceSets: Map<SourceSetData, EnvironmentAndFacade>? = null,
     private val unusedExtensionPoints: List<ExtensionPoint<*>>? = null,
     override val sourceSetCache: SourceSetCache
 ) : DokkaContext {
@@ -41,8 +39,6 @@ class MockContext(
     override val configuration: DokkaConfiguration
         get() = testConfiguration ?: throw IllegalStateException("This mock context doesn't provide configuration")
 
-    override val platforms: Map<SourceSetData, EnvironmentAndFacade>
-        get() = testSourceSets ?: throw IllegalStateException("This mock context doesn't provide platforms data")
     override val unusedPoints: Collection<ExtensionPoint<*>>
         get() = unusedExtensionPoints
             ?: throw IllegalStateException("This mock context doesn't provide unused extension points")
diff --git a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
index 2ca8523b..7248a4cb 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
@@ -2,7 +2,6 @@ package org.jetbrains.dokka.testApi.testRunner
 
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.DokkaGenerator
-import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.model.SourceSetCache
 import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaPlugin
@@ -19,17 +18,11 @@ internal class DokkaTestGenerator(
         val dokkaGenerator = DokkaGenerator(configuration, logger)
         val sourceSetsCache = SourceSetCache()
 
-        val platforms: Map<SourceSetData, EnvironmentAndFacade> = dokkaGenerator.setUpAnalysis(
-            configuration,
-            sourceSetsCache
-        )
-        analysisSetupStage(platforms)
-
         val context =
-            dokkaGenerator.initializePlugins(configuration, logger, platforms, sourceSetsCache, pluginOverrides)
+            dokkaGenerator.initializePlugins(configuration, logger, sourceSetsCache, pluginOverrides)
         pluginsSetupStage(context)
 
-        val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(platforms, context)
+        val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(context, sourceSetsCache)
         documentablesCreationStage(modulesFromPlatforms)
 
         val filteredModules = dokkaGenerator.transformDocumentationModelBeforeMerge(modulesFromPlatforms, context)
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index 9df20138..88595f85 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -106,7 +106,6 @@ abstract class AbstractCoreTest {
     }
 
     protected class TestBuilder {
-        var analysisSetupStage: (Map<SourceSetData, EnvironmentAndFacade>) -> Unit = {}
         var pluginsSetupStage: (DokkaContext) -> Unit = {}
         var documentablesCreationStage: (List<DModule>) -> Unit = {}
         var documentablesFirstTransformationStep: (List<DModule>) -> Unit = {}
@@ -118,7 +117,6 @@ abstract class AbstractCoreTest {
 
         @PublishedApi
         internal fun build() = TestMethods(
-            analysisSetupStage,
             pluginsSetupStage,
             documentablesCreationStage,
             documentablesFirstTransformationStep,
@@ -240,7 +238,6 @@ abstract class AbstractCoreTest {
 }
 
 data class TestMethods(
-    val analysisSetupStage: (Map<SourceSetData, EnvironmentAndFacade>) -> Unit,
     val pluginsSetupStage: (DokkaContext) -> Unit,
     val documentablesCreationStage: (List<DModule>) -> Unit,
     val documentablesFirstTransformationStep: (List<DModule>) -> Unit,
-- 
cgit 


From 8cb6efc97f8fa321381c95cc5f85a3ce7bc13c3f Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Fri, 19 Jun 2020 14:08:49 +0200
Subject: Remove SourceSetDataCache, rename PassConfiguration to DokkaSourceSet
 and use it instead of SourceSetData

---
 core/src/main/kotlin/DokkaBootstrapImpl.kt         |   6 +-
 core/src/main/kotlin/DokkaGenerator.kt             |  25 ++--
 core/src/main/kotlin/configuration.kt              |   4 +-
 core/src/main/kotlin/defaultConfiguration.kt       |   6 +-
 core/src/main/kotlin/model/Documentable.kt         |  59 +++++----
 core/src/main/kotlin/model/SourceSetData.kt        |  38 ------
 .../main/kotlin/model/documentableProperties.kt    |  12 +-
 core/src/main/kotlin/model/documentableUtils.kt    |  12 +-
 core/src/main/kotlin/pages/ContentNodes.kt         |  35 ++---
 core/src/main/kotlin/plugability/DokkaContext.kt   |   8 +-
 .../sources/SourceToDocumentableTranslator.kt      |   4 +-
 .../dokka/analysis/EnvironmentAndFacade.kt         |  10 +-
 .../org/jetbrains/dokka/analysis/KotlinAnalysis.kt |  24 ++--
 .../kotlin/allModulePage/MultimodulePageCreator.kt |  10 +-
 .../src/main/kotlin/renderers/DefaultRenderer.kt   |  28 ++--
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |  60 +++++----
 .../main/kotlin/renderers/html/NavigationPage.kt   |   8 +-
 .../kotlin/renderers/html/htmlPreprocessors.kt     |   2 +-
 .../resolvers/local/DefaultLocationProvider.kt     |  16 +--
 .../kotlin/resolvers/local/LocationProvider.kt     |   4 +-
 .../resolvers/local/MultimoduleLocationProvider.kt |   6 +-
 .../main/kotlin/signatures/JvmSignatureUtils.kt    |  12 +-
 .../kotlin/signatures/KotlinSignatureProvider.kt   |  16 ++-
 .../DeprecatedDocumentableFilterTransformer.kt     |  10 +-
 .../DocumentableVisibilityFilterTransformer.kt     |  36 +++--
 .../EmptyPackagesFilterTransformer.kt              |   8 +-
 .../InheritorsExtractorTransformer.kt              |   7 +-
 .../ModuleAndPackageDocumentationTransformer.kt    |   9 +-
 .../documentables/ReportUndocumentedTransformer.kt |  38 ++----
 .../pages/comments/CommentsToContentConverter.kt   |   4 +-
 .../pages/comments/DocTagToContentConverter.kt     |   4 +-
 .../pages/samples/SamplesTransformer.kt            |  13 +-
 .../pages/sourcelinks/SourceLinksTransformer.kt    |  18 +--
 .../DefaultDescriptorToDocumentableTranslator.kt   |  19 +--
 .../documentables/DefaultPageCreator.kt            | 147 +++++++++++++++------
 .../documentables/PageContentBuilder.kt            |  76 +++++------
 .../psi/DefaultPsiToDocumentableTranslator.kt      |   9 +-
 .../kotlin/content/params/ContentForParamsTest.kt  |  14 +-
 .../base/src/test/kotlin/model/InheritorsTest.kt   |   6 +-
 .../test/kotlin/renderers/RenderingOnlyTestBase.kt |   9 +-
 .../test/kotlin/renderers/html/DivergentTest.kt    |  32 ++++-
 .../renderers/html/SourceSetDependentHintTest.kt   |  26 +++-
 .../test/kotlin/renderers/html/defaultSourceSet.kt |  30 +++++
 plugins/gfm/src/main/kotlin/GfmPlugin.kt           |  19 +--
 .../main/kotlin/javadoc/JavadocLocationProvider.kt |  35 ++---
 .../src/main/kotlin/javadoc/JavadocPageCreator.kt  |  19 +--
 .../main/kotlin/javadoc/KorteJavadocRenderer.kt    |  10 +-
 .../kotlin/javadoc/pages/JavadocContentNodes.kt    |  22 +--
 .../main/kotlin/javadoc/pages/JavadocPageNodes.kt  |   2 +-
 runners/cli/src/main/kotlin/cli/main.kt            |  24 ++--
 .../jetbrains/dokka/gradle/DokkaCollectorTask.kt   |   2 +-
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt |  22 +--
 .../dokka/gradle/configurationImplementations.kt   |  98 +++++++++-----
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |   2 +-
 runners/maven-plugin/src/main/kotlin/DokkaMojo.kt  |   9 +-
 .../src/main/kotlin/testApi/context/MockContext.kt |   6 +-
 .../testApi/testRunner/DokkaTestGenerator.kt       |   8 +-
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |  22 ++-
 58 files changed, 656 insertions(+), 564 deletions(-)
 delete mode 100644 core/src/main/kotlin/model/SourceSetData.kt
 create mode 100644 plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index 94792303..bd632546 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -84,7 +84,7 @@ class DokkaBootstrapImpl : DokkaBootstrap {
 
     fun configure(logger: DokkaLogger, configuration: DokkaConfigurationImpl) = with(configuration) {
 
-        fun defaultLinks(config: PassConfigurationImpl): List<ExternalDocumentationLinkImpl> {
+        fun defaultLinks(config: DokkaSourceSetImpl): List<ExternalDocumentationLinkImpl> {
             val links = mutableListOf<ExternalDocumentationLinkImpl>()
             if (!config.noJdkLink)
                 links += DokkaConfiguration.ExternalDocumentationLink
@@ -100,8 +100,8 @@ class DokkaBootstrapImpl : DokkaBootstrap {
 
         val configurationWithLinks =
             configuration.copy(
-                passesConfigurations =
-                passesConfigurations.map {
+                sourceSets =
+                sourceSets.map {
                     val links: List<ExternalDocumentationLinkImpl> =
                         it.externalDocumentationLinks + defaultLinks(it)
                     it.copy(externalDocumentationLinks = links)
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index b88c6223..ce8d229a 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,8 +1,7 @@
 package org.jetbrains.dokka
 
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.*
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
@@ -18,13 +17,11 @@ class DokkaGenerator(
     private val logger: DokkaLogger
 ) {
     fun generate() = timed {
-        val sourceSetsCache = SourceSetCache()
-
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, sourceSetsCache)
+        val context = initializePlugins(configuration, logger)
 
         report("Creating documentation models")
-        val modulesFromPlatforms = createDocumentationModels(context, sourceSetsCache)
+        val modulesFromPlatforms = createDocumentationModels(context)
 
         report("Transforming documentation model before merging")
         val transformedDocumentationBeforeMerge = transformDocumentationModelBeforeMerge(modulesFromPlatforms, context)
@@ -48,9 +45,8 @@ class DokkaGenerator(
     }.dump("\n\n === TIME MEASUREMENT ===\n")
 
     fun generateAllModulesPage() = timed {
-        val sourceSetsCache = SourceSetCache()
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, sourceSetsCache)
+        val context = initializePlugins(configuration, logger)
 
         report("Creating all modules page")
         val pages = createAllModulePage(context)
@@ -66,15 +62,12 @@ class DokkaGenerator(
     fun initializePlugins(
         configuration: DokkaConfiguration,
         logger: DokkaLogger,
-        sourceSetsCache: SourceSetCache,
         pluginOverrides: List<DokkaPlugin> = emptyList()
-    ) = DokkaContext.create(configuration, logger, sourceSetsCache, pluginOverrides)
+    ) = DokkaContext.create(configuration, logger, pluginOverrides)
 
     fun createDocumentationModels(
-        context: DokkaContext,
-        sourceSetsCache: SourceSetCache
-    ) = context.configuration.passesConfigurations
-        .map { passConfiguration -> sourceSetsCache.getSourceSet(passConfiguration) }
+        context: DokkaContext
+    ) = context.configuration.sourceSets
         .flatMap { passConfiguration -> translateSources(passConfiguration, context) }
 
     fun transformDocumentationModelBeforeMerge(
@@ -133,9 +126,9 @@ class DokkaGenerator(
         }
     }
 
-    private fun translateSources(platformData: SourceSetData, context: DokkaContext) =
+    private fun translateSources(sourceSet: DokkaSourceSet, context: DokkaContext) =
         context[CoreExtensions.sourceToDocumentableTranslator].map {
-            it.invoke(platformData, context)
+            it.invoke(sourceSet, context)
         }
 }
 
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index b016f83d..463d2342 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -49,12 +49,12 @@ interface DokkaConfiguration {
     val cacheRoot: String?
     val offlineMode: Boolean
     val failOnWarning: Boolean
-    val passesConfigurations: List<PassConfiguration>
+    val sourceSets: List<DokkaSourceSet>
     val modules: List<DokkaModuleDescription>
     val pluginsClasspath: List<File>
     val pluginsConfiguration: Map<String, String>
 
-    interface PassConfiguration {
+    interface DokkaSourceSet {
         val moduleName: String
         val displayName: String
         val sourceSetID: String
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index 4e83d3c3..d3ac9df2 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -8,14 +8,14 @@ data class DokkaConfigurationImpl(
     override val format: String,
     override val cacheRoot: String?,
     override val offlineMode: Boolean,
-    override val passesConfigurations: List<PassConfigurationImpl>,
+    override val sourceSets: List<DokkaSourceSetImpl>,
     override val pluginsClasspath: List<File>,
     override val pluginsConfiguration: Map<String, String>,
     override val modules: List<DokkaModuleDescriptionImpl>,
     override val failOnWarning: Boolean
 ) : DokkaConfiguration
 
-data class PassConfigurationImpl(
+data class DokkaSourceSetImpl(
     override val moduleName: String,
     override val displayName: String,
     override val sourceSetID: String,
@@ -39,7 +39,7 @@ data class PassConfigurationImpl(
     override val noJdkLink: Boolean,
     override val suppressedFiles: List<String>,
     override val analysisPlatform: Platform
-) : DokkaConfiguration.PassConfiguration
+) : DokkaConfiguration.DokkaSourceSet
 
 data class DokkaModuleDescriptionImpl(
     override val name: String,
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index 768bddc5..35278302 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.model
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.properties.PropertyContainer
@@ -11,8 +12,8 @@ abstract class Documentable {
     abstract val dri: DRI
     abstract val children: List<Documentable>
     abstract val documentation: SourceSetDependent<DocumentationNode>
-    abstract val sourceSets: Set<SourceSetData>
-    abstract val expectPresentInSet: SourceSetData?
+    abstract val sourceSets: Set<DokkaSourceSet>
+    abstract val expectPresentInSet: DokkaSourceSet?
 
     override fun toString(): String =
         "${javaClass.simpleName}($dri)"
@@ -23,7 +24,7 @@ abstract class Documentable {
     override fun hashCode() = dri.hashCode()
 }
 
-typealias SourceSetDependent<T> = Map<SourceSetData, T>
+typealias SourceSetDependent<T> = Map<DokkaSourceSet, T>
 
 interface WithExpectActual {
     val sources: SourceSetDependent<DocumentableSource>
@@ -88,8 +89,8 @@ data class DModule(
     override val name: String,
     val packages: List<DPackage>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData? = null,
-    override val sourceSets: Set<SourceSetData>,
+    override val expectPresentInSet: DokkaSourceSet? = null,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DModule> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DModule> {
     override val dri: DRI = DRI.topLevel
@@ -106,8 +107,8 @@ data class DPackage(
     override val classlikes: List<DClasslike>,
     val typealiases: List<DTypeAlias>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData? = null,
-    override val sourceSets: Set<SourceSetData>,
+    override val expectPresentInSet: DokkaSourceSet? = null,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DPackage> = PropertyContainer.empty()
 ) : Documentable(), WithScope, WithExtraProperties<DPackage> {
     override val name = dri.packageName.orEmpty()
@@ -130,9 +131,9 @@ data class DClass(
     override val generics: List<DTypeParameter>,
     override val supertypes: SourceSetDependent<List<DRI>>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val modifier: SourceSetDependent<Modifier>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DClass> = PropertyContainer.empty()
 ) : DClasslike(), WithAbstraction, WithCompanion, WithConstructors, WithGenerics, WithSupertypes,
     WithExtraProperties<DClass> {
@@ -148,7 +149,7 @@ data class DEnum(
     override val name: String,
     val entries: List<DEnumEntry>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
@@ -157,7 +158,7 @@ data class DEnum(
     override val companion: DObject?,
     override val constructors: List<DFunction>,
     override val supertypes: SourceSetDependent<List<DRI>>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DEnum> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithConstructors, WithSupertypes, WithExtraProperties<DEnum> {
     override val children: List<Documentable>
@@ -170,11 +171,11 @@ data class DEnumEntry(
     override val dri: DRI,
     override val name: String,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DEnumEntry> = PropertyContainer.empty()
 ) : Documentable(), WithScope, WithExtraProperties<DEnumEntry> {
     override val children: List<Documentable>
@@ -189,14 +190,14 @@ data class DFunction(
     val isConstructor: Boolean,
     val parameters: List<DParameter>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val visibility: SourceSetDependent<Visibility>,
     override val type: Bound,
     override val generics: List<DTypeParameter>,
     override val receiver: DParameter?,
     override val modifier: SourceSetDependent<Modifier>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DFunction> = PropertyContainer.empty()
 ) : Documentable(), Callable, WithGenerics, WithExtraProperties<DFunction> {
     override val children: List<Documentable>
@@ -209,7 +210,7 @@ data class DInterface(
     override val dri: DRI,
     override val name: String,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
@@ -218,7 +219,7 @@ data class DInterface(
     override val companion: DObject?,
     override val generics: List<DTypeParameter>,
     override val supertypes: SourceSetDependent<List<DRI>>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DInterface> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithGenerics, WithSupertypes, WithExtraProperties<DInterface> {
     override val children: List<Documentable>
@@ -231,14 +232,14 @@ data class DObject(
     override val name: String?,
     override val dri: DRI,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
     override val classlikes: List<DClasslike>,
     override val visibility: SourceSetDependent<Visibility>,
     override val supertypes: SourceSetDependent<List<DRI>>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DObject> = PropertyContainer.empty()
 ) : DClasslike(), WithSupertypes, WithExtraProperties<DObject> {
     override val children: List<Documentable>
@@ -251,7 +252,7 @@ data class DAnnotation(
     override val name: String,
     override val dri: DRI,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val functions: List<DFunction>,
     override val properties: List<DProperty>,
@@ -260,7 +261,7 @@ data class DAnnotation(
     override val companion: DObject?,
     override val constructors: List<DFunction>,
     override val generics: List<DTypeParameter>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DAnnotation> = PropertyContainer.empty()
 ) : DClasslike(), WithCompanion, WithConstructors, WithExtraProperties<DAnnotation>, WithGenerics {
     override val children: List<Documentable>
@@ -273,7 +274,7 @@ data class DProperty(
     override val dri: DRI,
     override val name: String,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     override val sources: SourceSetDependent<DocumentableSource>,
     override val visibility: SourceSetDependent<Visibility>,
     override val type: Bound,
@@ -281,7 +282,7 @@ data class DProperty(
     val setter: DFunction?,
     val getter: DFunction?,
     override val modifier: SourceSetDependent<Modifier>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val generics: List<DTypeParameter>,
     override val extra: PropertyContainer<DProperty> = PropertyContainer.empty()
 ) : Documentable(), Callable, WithExtraProperties<DProperty>, WithGenerics {
@@ -296,9 +297,9 @@ data class DParameter(
     override val dri: DRI,
     override val name: String?,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     val type: Bound,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DParameter> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DParameter> {
     override val children: List<Nothing>
@@ -311,9 +312,9 @@ data class DTypeParameter(
     override val dri: DRI,
     override val name: String,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
+    override val expectPresentInSet: DokkaSourceSet?,
     val bounds: List<Bound>,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DTypeParameter> = PropertyContainer.empty()
 ) : Documentable(), WithExtraProperties<DTypeParameter> {
     override val children: List<Nothing>
@@ -329,8 +330,8 @@ data class DTypeAlias(
     val underlyingType: SourceSetDependent<Bound>,
     override val visibility: SourceSetDependent<Visibility>,
     override val documentation: SourceSetDependent<DocumentationNode>,
-    override val expectPresentInSet: SourceSetData?,
-    override val sourceSets: Set<SourceSetData>,
+    override val expectPresentInSet: DokkaSourceSet?,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<DTypeAlias> = PropertyContainer.empty()
 ) : Documentable(), WithType, WithVisibility, WithExtraProperties<DTypeAlias> {
     override val children: List<Nothing>
diff --git a/core/src/main/kotlin/model/SourceSetData.kt b/core/src/main/kotlin/model/SourceSetData.kt
deleted file mode 100644
index 3e38cc7b..00000000
--- a/core/src/main/kotlin/model/SourceSetData.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-package org.jetbrains.dokka.model
-
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.Platform
-import org.jetbrains.dokka.plugability.DokkaContext
-
-data class SourceSetData(
-    val moduleName: String,
-    val sourceSetID: String,
-    val displayName: String,
-    val platform: Platform,
-    val sourceRoots: List<DokkaConfiguration.SourceRoot> = emptyList(),
-    val dependentSourceSets: List<String> = emptyList()
-)
-
-class SourceSetCache {
-    private val sourceSets = HashMap<String, SourceSetData>()
-
-    val allSourceSets: List<SourceSetData>
-        get() = sourceSets.values.toList()
-
-    fun getSourceSet(pass: DokkaConfiguration.PassConfiguration) =
-        sourceSets.getOrPut(pass.sourceSetID,
-            {
-                SourceSetData(
-                    pass.moduleName,
-                    pass.sourceSetID,
-                    pass.displayName,
-                    pass.analysisPlatform,
-                    pass.sourceRoots,
-                    pass.dependentSourceSets
-                )
-            }
-        )
-}
-
-fun DokkaContext.sourceSet(pass: DokkaConfiguration.PassConfiguration): SourceSetData =
-    sourceSetCache.getSourceSet(pass)
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/documentableProperties.kt b/core/src/main/kotlin/model/documentableProperties.kt
index 2aec199c..cd6a9335 100644
--- a/core/src/main/kotlin/model/documentableProperties.kt
+++ b/core/src/main/kotlin/model/documentableProperties.kt
@@ -1,26 +1,26 @@
 package org.jetbrains.dokka.model
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.properties.ExtraProperty
 import org.jetbrains.dokka.model.properties.MergeStrategy
 
-data class InheritedFunction(val inheritedFrom: SourceSetDependent<DRI?>): ExtraProperty<DFunction> {
+data class InheritedFunction(val inheritedFrom: SourceSetDependent<DRI?>) : ExtraProperty<DFunction> {
     companion object : ExtraProperty.Key<DFunction, InheritedFunction> {
         override fun mergeStrategyFor(left: InheritedFunction, right: InheritedFunction) = MergeStrategy.Replace(
             InheritedFunction(left.inheritedFrom + right.inheritedFrom)
         )
     }
 
-    fun isInherited(sourceSetDependent: SourceSetData): Boolean = inheritedFrom[sourceSetDependent] != null
+    fun isInherited(sourceSetDependent: DokkaSourceSet): Boolean = inheritedFrom[sourceSetDependent] != null
 
     override val key: ExtraProperty.Key<DFunction, *> = InheritedFunction
 }
 
-data class ImplementedInterfaces(val interfaces: SourceSetDependent<List<DRI>>): ExtraProperty<Documentable> {
+data class ImplementedInterfaces(val interfaces: SourceSetDependent<List<DRI>>) : ExtraProperty<Documentable> {
     companion object : ExtraProperty.Key<Documentable, ImplementedInterfaces> {
-        override fun mergeStrategyFor(left: ImplementedInterfaces, right: ImplementedInterfaces) = MergeStrategy.Replace(
-            ImplementedInterfaces(left.interfaces + right.interfaces)
-        )
+        override fun mergeStrategyFor(left: ImplementedInterfaces, right: ImplementedInterfaces) =
+            MergeStrategy.Replace(ImplementedInterfaces(left.interfaces + right.interfaces))
     }
 
     override val key: ExtraProperty.Key<Documentable, *> = ImplementedInterfaces
diff --git a/core/src/main/kotlin/model/documentableUtils.kt b/core/src/main/kotlin/model/documentableUtils.kt
index 2d4ade15..7057a62c 100644
--- a/core/src/main/kotlin/model/documentableUtils.kt
+++ b/core/src/main/kotlin/model/documentableUtils.kt
@@ -1,12 +1,14 @@
 package org.jetbrains.dokka.model
 
-fun <T> SourceSetDependent<T>.filtered(platformDataList: Set<SourceSetData>) = filter { it.key in platformDataList }
-fun SourceSetData?.filtered(platformDataList: Set<SourceSetData>) = takeIf { this in platformDataList }
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 
-fun DTypeParameter.filter(filteredData: Set<SourceSetData>) =
-    if (filteredData.containsAll(sourceSets)) this
+fun <T> SourceSetDependent<T>.filtered(sourceSets: Set<DokkaSourceSet>) = filter { it.key in sourceSets }
+fun DokkaSourceSet?.filtered(sourceSets: Set<DokkaSourceSet>) = takeIf { this in sourceSets }
+
+fun DTypeParameter.filter(filteredSet: Set<DokkaSourceSet>) =
+    if (filteredSet.containsAll(sourceSets)) this
     else {
-        val intersection = filteredData.intersect(sourceSets)
+        val intersection = filteredSet.intersect(sourceSets)
         if (intersection.isEmpty()) null
         else DTypeParameter(
             dri,
diff --git a/core/src/main/kotlin/pages/ContentNodes.kt b/core/src/main/kotlin/pages/ContentNodes.kt
index 1b9c937d..dc23a082 100644
--- a/core/src/main/kotlin/pages/ContentNodes.kt
+++ b/core/src/main/kotlin/pages/ContentNodes.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.pages
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.model.properties.WithExtraProperties
 
@@ -11,7 +11,7 @@ data class DCI(val dri: Set<DRI>, val kind: Kind) {
 
 interface ContentNode : WithExtraProperties<ContentNode> {
     val dci: DCI
-    val sourceSets: Set<SourceSetData>
+    val sourceSets: Set<DokkaSourceSet>
     val style: Set<Style>
 
     fun hasAnyContent(): Boolean
@@ -21,7 +21,7 @@ interface ContentNode : WithExtraProperties<ContentNode> {
 data class ContentText(
     val text: String,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentNode {
@@ -32,7 +32,7 @@ data class ContentText(
 
 // TODO: Remove
 data class ContentBreakLine(
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val dci: DCI = DCI(emptySet(), ContentKind.Empty),
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
@@ -47,11 +47,12 @@ data class ContentHeader(
     override val children: List<ContentNode>,
     val level: Int,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
     constructor(level: Int, c: ContentComposite) : this(c.children, level, c.dci, c.sourceSets, c.style, c.extra)
+
     override fun withNewExtras(newExtras: PropertyContainer<ContentNode>): ContentHeader = copy(extra = newExtras)
 }
 
@@ -60,7 +61,7 @@ data class ContentCode(
     override val children: List<ContentNode>,
     val language: String,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -75,7 +76,7 @@ data class ContentDRILink(
     override val children: List<ContentNode>,
     val address: DRI,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -87,7 +88,7 @@ data class ContentResolvedLink(
     override val children: List<ContentNode>,
     val address: String,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -101,7 +102,7 @@ data class ContentEmbeddedResource(
     val address: String,
     val altText: String?,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style> = emptySet(),
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentLink {
@@ -121,7 +122,7 @@ data class ContentTable(
     val header: List<ContentGroup>,
     override val children: List<ContentGroup>,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -133,7 +134,7 @@ data class ContentList(
     override val children: List<ContentNode>,
     val ordered: Boolean,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -144,7 +145,7 @@ data class ContentList(
 data class ContentGroup(
     override val children: List<ContentNode>,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -164,7 +165,7 @@ data class ContentDivergentGroup(
 ) : ContentComposite {
     data class GroupID(val name: String)
 
-    override val sourceSets: Set<SourceSetData>
+    override val sourceSets: Set<DokkaSourceSet>
         get() = children.flatMap { it.sourceSets }.distinct().toSet()
 
     override fun withNewExtras(newExtras: PropertyContainer<ContentNode>): ContentDivergentGroup =
@@ -177,7 +178,7 @@ data class ContentDivergentInstance(
     val divergent: ContentNode,
     val after: ContentNode?,
     override val dci: DCI,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val style: Set<Style>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentComposite {
@@ -190,7 +191,7 @@ data class ContentDivergentInstance(
 
 data class PlatformHintedContent(
     val inner: ContentNode,
-    override val sourceSets: Set<SourceSetData>
+    override val sourceSets: Set<DokkaSourceSet>
 ) : ContentComposite {
     override val children = listOf(inner)
 
@@ -231,9 +232,9 @@ enum class ContentStyle : Style {
     RowTitle, TabbedContent, WithExtraAttributes
 }
 
-object CommentTable: Style
+object CommentTable : Style
 
-object MultimoduleTable: Style
+object MultimoduleTable : Style
 
 fun ContentNode.dfs(predicate: (ContentNode) -> Boolean): ContentNode? = if (predicate(this)) {
     this
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index a2ff26c7..15349ff0 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.model.SourceSetCache
 import org.jetbrains.dokka.utilities.DokkaLogger
 import java.io.File
 import java.net.URLClassLoader
@@ -18,7 +17,6 @@ interface DokkaContext {
 
     fun <T, E> single(point: E): T where T : Any, E : ExtensionPoint<T>
 
-    val sourceSetCache: SourceSetCache
     val logger: DokkaLogger
     val configuration: DokkaConfiguration
     val unusedPoints: Collection<ExtensionPoint<*>>
@@ -28,10 +26,9 @@ interface DokkaContext {
         fun create(
             configuration: DokkaConfiguration,
             logger: DokkaLogger,
-            sourceSetsCache: SourceSetCache,
             pluginOverrides: List<DokkaPlugin>
         ): DokkaContext =
-            DokkaContextConfigurationImpl(logger, configuration, sourceSetsCache).apply {
+            DokkaContextConfigurationImpl(logger, configuration).apply {
                 // File(it.path) is a workaround for an incorrect filesystem in a File instance returned by Gradle.
                 configuration.pluginsClasspath.map { File(it.path).toURI().toURL() }
                     .toTypedArray()
@@ -54,8 +51,7 @@ interface DokkaContextConfiguration {
 
 private class DokkaContextConfigurationImpl(
     override val logger: DokkaLogger,
-    override val configuration: DokkaConfiguration,
-    override val sourceSetCache: SourceSetCache
+    override val configuration: DokkaConfiguration
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
     private val pluginStubs = mutableMapOf<KClass<*>, DokkaPlugin>()
diff --git a/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt b/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
index f9c0a3d0..6bc8fb14 100644
--- a/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
+++ b/core/src/main/kotlin/transformers/sources/SourceToDocumentableTranslator.kt
@@ -1,9 +1,9 @@
 package org.jetbrains.dokka.transformers.sources
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface SourceToDocumentableTranslator {
-    fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule
+    fun invoke(sourceSet: DokkaSourceSet, context: DokkaContext): DModule
 }
\ No newline at end of file
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 9d15123a..a12becee 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
@@ -14,21 +14,21 @@ import java.io.File
 internal fun createEnvironmentAndFacade(
     logger: DokkaLogger,
     configuration: DokkaConfiguration,
-    pass: DokkaConfiguration.PassConfiguration
+    sourceSet: DokkaConfiguration.DokkaSourceSet
 ): EnvironmentAndFacade =
-    AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
+    AnalysisEnvironment(DokkaMessageCollector(logger), sourceSet.analysisPlatform).run {
         if (analysisPlatform == Platform.jvm) {
             addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
         }
-        pass.classpath.forEach { addClasspath(File(it)) }
+        sourceSet.classpath.forEach { addClasspath(File(it)) }
 
         addSources(
-            (pass.sourceRoots + configuration.passesConfigurations.filter { it.sourceSetID in pass.dependentSourceSets }
+            (sourceSet.sourceRoots + configuration.sourceSets.filter { it.sourceSetID in sourceSet.dependentSourceSets }
                 .flatMap { it.sourceRoots })
                 .map { it.path }
         )
 
-        loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
+        loadLanguageVersionSettings(sourceSet.languageVersion, sourceSet.apiVersion)
 
         val environment = createCoreEnvironment()
         val (facade, _) = createResolutionFacade(environment)
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
index cd07b2a3..426ffdde 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
@@ -2,45 +2,37 @@
 
 package org.jetbrains.dokka.analysis
 
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
 
 fun KotlinAnalysis(context: DokkaContext): KotlinAnalysis {
-    val environments = context.configuration.passesConfigurations
-        .associate { passConfiguration ->
-            context.sourceSetCache.getSourceSet(passConfiguration) to createEnvironmentAndFacade(
+    val environments = context.configuration.sourceSets
+        .associate { sourceSet ->
+            sourceSet to createEnvironmentAndFacade(
                 logger = context.logger,
                 configuration = context.configuration,
-                pass = passConfiguration
+                sourceSet = sourceSet
             )
         }
 
-    return KotlinAnalysisImpl(context.sourceSetCache, environments)
+    return KotlinAnalysisImpl(environments)
 }
 
 interface KotlinAnalysis : SourceSetDependent<EnvironmentAndFacade> {
-    override fun get(key: SourceSetData): EnvironmentAndFacade
+    override fun get(key: DokkaSourceSet): EnvironmentAndFacade
     operator fun get(sourceSetID: String): EnvironmentAndFacade
-    operator fun get(passConfiguration: DokkaConfiguration.PassConfiguration): EnvironmentAndFacade
 }
 
 internal class KotlinAnalysisImpl(
-    private val sourceSetCache: SourceSetCache,
     private val environments: SourceSetDependent<EnvironmentAndFacade>
 ) : KotlinAnalysis, SourceSetDependent<EnvironmentAndFacade> by environments {
 
-    override fun get(key: SourceSetData): EnvironmentAndFacade {
+    override fun get(key: DokkaSourceSet): EnvironmentAndFacade {
         return environments[key] ?: throw IllegalStateException("Missing EnvironmentAndFacade for sourceSet $key")
     }
 
     override fun get(sourceSetID: String): EnvironmentAndFacade {
         return environments.entries.first { (sourceSet, _) -> sourceSet.sourceSetID == sourceSetID }.value
     }
-
-    override fun get(passConfiguration: DokkaConfiguration.PassConfiguration): EnvironmentAndFacade {
-        return get(sourceSetCache.getSourceSet(passConfiguration))
-    }
 }
diff --git a/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt b/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
index cdaa0274..e3da9ecc 100644
--- a/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
+++ b/plugins/base/src/main/kotlin/allModulePage/MultimodulePageCreator.kt
@@ -1,11 +1,11 @@
 package org.jetbrains.dokka.base.allModulePage
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.local.MultimoduleLocationProvider.Companion.MULTIMODULE_PACKAGE_PLACEHOLDER
 import org.jetbrains.dokka.base.transformers.pages.comments.DocTagToContentConverter
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.doc.P
 import org.jetbrains.dokka.pages.*
@@ -30,9 +30,13 @@ class MultimodulePageCreator(
         if (commentsConverter == null || signatureProvider == null)
             throw IllegalStateException("Both comments converter and signature provider must not be null")
 
-        val sourceSetData = emptySet<SourceSetData>()
+        val sourceSetData = emptySet<DokkaSourceSet>()
         val builder = PageContentBuilder(commentsConverter, signatureProvider, context.logger)
-        val contentNode = builder.contentFor(dri = DRI(MULTIMODULE_PACKAGE_PLACEHOLDER), kind = ContentKind.Cover, sourceSets = sourceSetData) {
+        val contentNode = builder.contentFor(
+            dri = DRI(MULTIMODULE_PACKAGE_PLACEHOLDER),
+            kind = ContentKind.Cover,
+            sourceSets = sourceSetData
+        ) {
             header(2, "All modules:")
             table(styles = setOf(MultimoduleTable)) {
                 modules.mapNotNull { module ->
diff --git a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
index 141a18e6..f4d547e3 100644
--- a/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -1,10 +1,12 @@
 package org.jetbrains.dokka.base.renderers
 
-import kotlinx.coroutines.*
-import kotlinx.html.FlowContent
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.local.LocationProvider
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
@@ -28,7 +30,7 @@ abstract class DefaultRenderer<T>(
     abstract fun T.buildList(
         node: ContentList,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     )
 
     abstract fun T.buildNewLine()
@@ -36,7 +38,7 @@ abstract class DefaultRenderer<T>(
     abstract fun T.buildTable(
         node: ContentTable,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     )
 
     abstract fun T.buildText(textNode: ContentText)
@@ -48,18 +50,18 @@ abstract class DefaultRenderer<T>(
     open fun T.buildPlatformDependent(
         content: PlatformHintedContent,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) = buildContentNode(content.inner, pageContext)
 
     open fun T.buildGroup(
         node: ContentGroup,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) =
         wrapGroup(node, pageContext) { node.children.forEach { it.build(this, pageContext, sourceSetRestriction) } }
 
     open fun T.buildDivergent(node: ContentDivergentGroup, pageContext: ContentPage) =
-         node.children.forEach { it.build(this, pageContext) }
+        node.children.forEach { it.build(this, pageContext) }
 
     open fun T.wrapGroup(node: ContentGroup, pageContext: ContentPage, childrenCallback: T.() -> Unit) =
         childrenCallback()
@@ -67,7 +69,7 @@ abstract class DefaultRenderer<T>(
     open fun T.buildLinkText(
         nodes: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
         nodes.forEach { it.build(this, pageContext, sourceSetRestriction) }
     }
@@ -79,7 +81,7 @@ abstract class DefaultRenderer<T>(
     open fun T.buildHeader(
         node: ContentHeader,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
         buildHeader(node.level, node) { node.children.forEach { it.build(this, pageContext, sourceSetRestriction) } }
     }
@@ -87,16 +89,16 @@ abstract class DefaultRenderer<T>(
     open fun ContentNode.build(
         builder: T,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) =
         builder.buildContentNode(this, pageContext, sourceSetRestriction)
 
     open fun T.buildContentNode(
         node: ContentNode,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
-        if (sourceSetRestriction == null || node.sourceSets.any { it in sourceSetRestriction }  ) {
+        if (sourceSetRestriction == null || node.sourceSets.any { it in sourceSetRestriction }) {
             when (node) {
                 is ContentText -> buildText(node)
                 is ContentHeader -> buildHeader(node, pageContext, sourceSetRestriction)
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 43722888..ee6f1e1f 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -1,13 +1,15 @@
 package org.jetbrains.dokka.base.renderers.html
 
-import kotlinx.coroutines.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.DefaultRenderer
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -20,11 +22,10 @@ open class HtmlRenderer(
     context: DokkaContext
 ) : DefaultRenderer<FlowContent>(context) {
 
-    private val sourceSetDependencyMap = with(context.sourceSetCache) {
-        allSourceSets.map { sourceSet ->
-            sourceSet to allSourceSets.filter { sourceSet.dependentSourceSets.contains(it.sourceSetID) }
-        }.toMap()
-    }
+    private val sourceSetDependencyMap = context.configuration.sourceSets.map { sourceSet ->
+        sourceSet to context.configuration.sourceSets.filter { sourceSet.dependentSourceSets.contains(it.sourceSetID) }
+    }.toMap()
+
 
     private val pageList = mutableMapOf<String, Pair<String, String>>()
 
@@ -94,7 +95,7 @@ open class HtmlRenderer(
                 button(classes = "platform-tag platform-selector") {
                     attributes["data-active"] = ""
                     attributes["data-filter"] = it.sourceSetID
-                    when (it.platform.key) {
+                    when (it.analysisPlatform.key) {
                         "common" -> classes = classes + "common-like"
                         "native" -> classes = classes + "native-like"
                         "jvm" -> classes = classes + "jvm-like"
@@ -138,7 +139,7 @@ open class HtmlRenderer(
     override fun FlowContent.buildPlatformDependent(
         content: PlatformHintedContent,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) =
         buildPlatformDependent(
             content.sourceSets.filter {
@@ -150,7 +151,7 @@ open class HtmlRenderer(
         )
 
     private fun FlowContent.buildPlatformDependent(
-        nodes: Map<SourceSetData, Collection<ContentNode>>,
+        nodes: Map<DokkaSourceSet, Collection<ContentNode>>,
         pageContext: ContentPage,
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
         styles: Set<Style> = emptySet()
@@ -172,7 +173,7 @@ open class HtmlRenderer(
                             if (index == 0) attributes["data-active"] = ""
                             attributes["data-toggle"] = pair.first.sourceSetID
                             when (
-                                pair.first.platform.key
+                                pair.first.analysisPlatform.key
                                 ) {
                                 "common" -> classes = classes + "common-like"
                                 "native" -> classes = classes + "native-like"
@@ -192,9 +193,9 @@ open class HtmlRenderer(
     }
 
     private fun contentsForSourceSetDependent(
-        nodes: Map<SourceSetData, Collection<ContentNode>>,
+        nodes: Map<DokkaSourceSet, Collection<ContentNode>>,
         pageContext: ContentPage,
-    ): List<Pair<SourceSetData, String>> {
+    ): List<Pair<DokkaSourceSet, String>> {
         var counter = 0
         return nodes.toList().map { (sourceSet, elements) ->
             sourceSet to createHTML(prettyPrint = false).div {
@@ -203,8 +204,8 @@ open class HtmlRenderer(
                 }
             }.stripDiv()
         }.groupBy(
-            Pair<SourceSetData, String>::second,
-            Pair<SourceSetData, String>::first
+            Pair<DokkaSourceSet, String>::second,
+            Pair<DokkaSourceSet, String>::first
         ).entries.flatMap { (html, sourceSets) ->
             sourceSets.filterNot {
                 sourceSetDependencyMap[it].orEmpty().any { dependency -> sourceSets.contains(dependency) }
@@ -238,8 +239,8 @@ open class HtmlRenderer(
                     )
                 }
             }.groupBy(
-                Pair<Pair<ContentDivergentInstance, SourceSetData>, Pair<String, String>>::second,
-                Pair<Pair<ContentDivergentInstance, SourceSetData>, Pair<String, String>>::first
+                Pair<Pair<ContentDivergentInstance, DokkaSourceSet>, Pair<String, String>>::second,
+                Pair<Pair<ContentDivergentInstance, DokkaSourceSet>, Pair<String, String>>::first
             )
 
         distinct.forEach {
@@ -293,14 +294,14 @@ open class HtmlRenderer(
     override fun FlowContent.buildList(
         node: ContentList,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) = if (node.ordered) ol { buildListItems(node.children, pageContext, sourceSetRestriction) }
     else ul { buildListItems(node.children, pageContext, sourceSetRestriction) }
 
     open fun OL.buildListItems(
         items: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
         items.forEach {
             if (it is ContentList)
@@ -313,7 +314,7 @@ open class HtmlRenderer(
     open fun UL.buildListItems(
         items: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>? = null
+        sourceSetRestriction: Set<DokkaSourceSet>? = null
     ) {
         items.forEach {
             if (it is ContentList)
@@ -340,7 +341,7 @@ open class HtmlRenderer(
     private fun FlowContent.buildRow(
         node: ContentGroup,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?,
+        sourceSetRestriction: Set<DokkaSourceSet>?,
         style: Set<Style>
     ) {
         node.children
@@ -393,11 +394,11 @@ open class HtmlRenderer(
             }
     }
 
-    private fun FlowContent.createPlatformTagBubbles(sourceSets: List<SourceSetData>) {
+    private fun FlowContent.createPlatformTagBubbles(sourceSets: List<DokkaSourceSet>) {
         div("platform-tags") {
             sourceSets.forEach {
                 div("platform-tag") {
-                    when (it.platform.key) {
+                    when (it.analysisPlatform.key) {
                         "common" -> classes = classes + "common-like"
                         "native" -> classes = classes + "native-like"
                         "jvm" -> classes = classes + "jvm-like"
@@ -409,7 +410,7 @@ open class HtmlRenderer(
         }
     }
 
-    private fun FlowContent.createPlatformTags(node: ContentNode, sourceSetRestriction: Set<SourceSetData>? = null) {
+    private fun FlowContent.createPlatformTags(node: ContentNode, sourceSetRestriction: Set<DokkaSourceSet>? = null) {
         node.takeIf { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }?.let {
             createPlatformTagBubbles(node.sourceSets.filter {
                 sourceSetRestriction == null || it in sourceSetRestriction
@@ -420,7 +421,7 @@ open class HtmlRenderer(
     override fun FlowContent.buildTable(
         node: ContentTable,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) {
         when (node.dci.kind) {
             ContentKind.Comment -> buildDefaultTable(node, pageContext, sourceSetRestriction)
@@ -437,7 +438,7 @@ open class HtmlRenderer(
     fun FlowContent.buildDefaultTable(
         node: ContentTable,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) {
         table {
             thead {
@@ -522,7 +523,7 @@ open class HtmlRenderer(
 
     fun FlowContent.buildLink(
         to: DRI,
-        platforms: List<SourceSetData>,
+        platforms: List<DokkaSourceSet>,
         from: PageNode? = null,
         block: FlowContent.() -> Unit
     ) = buildLink(locationProvider.resolve(to, platforms, from), block)
@@ -562,7 +563,7 @@ open class HtmlRenderer(
     private fun getSymbolSignature(page: ContentPage) = page.content.dfs { it.dci.kind == ContentKind.Symbol }
 
     private fun flattenToText(node: ContentNode): String {
-        fun getContentTextNodes(node: ContentNode, sourceSetRestriction: SourceSetData): List<ContentText> =
+        fun getContentTextNodes(node: ContentNode, sourceSetRestriction: DokkaSourceSet): List<ContentText> =
             when (node) {
                 is ContentText -> listOf(node)
                 is ContentComposite -> node.children
@@ -573,7 +574,8 @@ open class HtmlRenderer(
                 else -> emptyList()
             }
 
-        val sourceSetRestriction = node.sourceSets.find { it.platform == Platform.common } ?: node.sourceSets.first()
+        val sourceSetRestriction =
+            node.sourceSets.find { it.analysisPlatform == Platform.common } ?: node.sourceSets.first()
         return getContentTextNodes(node, sourceSetRestriction).joinToString("") { it.text }
     }
 
diff --git a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
index 4048c11e..eb563dbd 100644
--- a/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/NavigationPage.kt
@@ -3,7 +3,7 @@ package org.jetbrains.dokka.base.renderers.html
 import kotlinx.html.*
 import kotlinx.html.stream.createHTML
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RendererSpecificPage
 import org.jetbrains.dokka.pages.RenderingStrategy
@@ -25,7 +25,7 @@ class NavigationPage(val root: NavigationNode) : RendererSpecificPage {
                 id = navId
                 attributes["pageId"] = node.dri.toString()
                 div("overview") {
-                    buildLink(node.dri, node.platforms) { +node.name }
+                    buildLink(node.dri, node.sourceSets) { +node.name }
                     if (node.children.isNotEmpty()) {
                         span("navButton") {
                             onClick = """document.getElementById("$navId").classList.toggle("hidden");"""
@@ -41,11 +41,11 @@ class NavigationPage(val root: NavigationNode) : RendererSpecificPage {
 class NavigationNode(
     val name: String,
     val dri: DRI,
-    val platforms: List<SourceSetData>,
+    val sourceSets: List<DokkaSourceSet>,
     val children: List<NavigationNode>
 )
 
 fun NavigationPage.transform(block: (NavigationNode) -> NavigationNode) = NavigationPage(root.transform(block))
 
 fun NavigationNode.transform(block: (NavigationNode) -> NavigationNode) =
-    run(block).let { NavigationNode(it.name, it.dri, it.platforms, it.children.map(block)) }
+    run(block).let { NavigationNode(it.name, it.dri, it.sourceSets, it.children.map(block)) }
diff --git a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
index cdb30555..af0525d7 100644
--- a/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/htmlPreprocessors.kt
@@ -86,7 +86,7 @@ object StyleAndScriptsAppender : PageTransformer {
 
 class SourcesetDependencyAppender(val context: DokkaContext) : PageTransformer{
     override fun invoke(input: RootPageNode): RootPageNode {
-        val dependenciesMap = context.configuration.passesConfigurations.map {
+        val dependenciesMap = context.configuration.sourceSets.map {
             it.sourceSetID to it.dependentSourceSets
         }.toMap()
         fun createDependenciesJson() : String = "sourceset_dependencies = '{${
diff --git a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
index a9e58f17..eada2e3b 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/DefaultLocationProvider.kt
@@ -1,16 +1,14 @@
 package org.jetbrains.dokka.base.resolvers.local
 
 import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.external.ExternalLocationProvider
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
-import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
 import org.jetbrains.dokka.plugability.query
-import java.lang.IllegalStateException
 import java.net.HttpURLConnection
 import java.net.URL
 import java.net.URLConnection
@@ -48,14 +46,12 @@ open class DefaultLocationProvider(
     override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String =
         pathTo(node, context) + if (!skipExtension) extension else ""
 
-    override fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode?): String =
+    override fun resolve(dri: DRI, sourceSets: List<DokkaSourceSet>, context: PageNode?): String =
         pagesIndex[dri]?.let { resolve(it, context) } ?:
         // Not found in PageGraph, that means it's an external link
-        getLocation(dri,
-            this.dokkaContext.configuration.passesConfigurations
-                .filter { passConfig ->
-                    sourceSets.toSet().contains(dokkaContext.sourceSet(passConfig))
-                }
+        getLocation(
+            dri,
+            sourceSets
                 .groupBy({ it.jdkVersion }, { it.externalDocumentationLinks })
                 .map { it.key to it.value.flatten().distinct() }.toMap()
         )
@@ -105,7 +101,7 @@ open class DefaultLocationProvider(
         // Not in cache, resolve packageLists
         for ((jdk, links) in toResolve) {
             for (link in links) {
-                if(dokkaContext.configuration.offlineMode && link.packageListUrl.protocol.toLowerCase() != "file")
+                if (dokkaContext.configuration.offlineMode && link.packageListUrl.protocol.toLowerCase() != "file")
                     continue
                 val locationInfo =
                     loadPackageList(jdk, link.packageListUrl)
diff --git a/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
index c6c48d63..d6d616f3 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/LocationProvider.kt
@@ -1,12 +1,12 @@
 package org.jetbrains.dokka.base.resolvers.local
 
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RootPageNode
 
 interface LocationProvider {
-    fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode? = null): String
+    fun resolve(dri: DRI, sourceSets: List<DokkaSourceSet>, context: PageNode? = null): String
     fun resolve(node: PageNode, context: PageNode? = null, skipExtension: Boolean = false): String
     fun resolveRoot(node: PageNode): String
     fun ancestors(node: PageNode): List<PageNode>
diff --git a/plugins/base/src/main/kotlin/resolvers/local/MultimoduleLocationProvider.kt b/plugins/base/src/main/kotlin/resolvers/local/MultimoduleLocationProvider.kt
index 21692bf9..39b005a1 100644
--- a/plugins/base/src/main/kotlin/resolvers/local/MultimoduleLocationProvider.kt
+++ b/plugins/base/src/main/kotlin/resolvers/local/MultimoduleLocationProvider.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.base.resolvers.local
 
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -14,10 +14,10 @@ class MultimoduleLocationProvider(private val root: RootPageNode, context: Dokka
         it.name to it.path
     }.toMap()
 
-    override fun resolve(dri: DRI, platforms: List<SourceSetData>, context: PageNode?): String =
+    override fun resolve(dri: DRI, sourceSets: List<DokkaSourceSet>, context: PageNode?): String =
         dri.takeIf { it.packageName == MULTIMODULE_PACKAGE_PLACEHOLDER }?.classNames?.let { paths[it] }?.let {
             "$it/${dri.classNames}/index.html"
-        } ?: defaultLocationProvider.resolve(dri, platforms, context)
+        } ?: defaultLocationProvider.resolve(dri, sourceSets, context)
 
     override fun resolve(node: PageNode, context: PageNode?, skipExtension: Boolean): String =
         defaultLocationProvider.resolve(node, context, skipExtension)
diff --git a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
index 8dbe7b12..f042eae3 100644
--- a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
+++ b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
@@ -1,10 +1,12 @@
 package org.jetbrains.dokka.base.signatures
 
+import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.WithExtraProperties
 import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 
 interface JvmSignatureUtils {
 
@@ -73,7 +75,7 @@ interface JvmSignatureUtils {
                     is All -> All
                     is Never, is OnlyOnce -> Never
                 }.let { strategy ->
-                     valueToSignature(it.value, strategy, listBrackets, classExtension)
+                    valueToSignature(it.value, strategy, listBrackets, classExtension)
                 }
                 if (i != a.params.entries.size - 1) text(", ")
             }
@@ -130,11 +132,11 @@ interface JvmSignatureUtils {
         }
     }
 
-    fun <T : Documentable> WithExtraProperties<T>.stylesIfDeprecated(sourceSetData: SourceSetData): Set<TextStyle> =
+    fun <T : Documentable> WithExtraProperties<T>.stylesIfDeprecated(sourceSetData: DokkaSourceSet): Set<TextStyle> =
         if (extra[Annotations]?.content?.get(sourceSetData)?.any {
-            it.dri == DRI("kotlin", "Deprecated")
-                    || it.dri == DRI("java.lang", "Deprecated")
-        } == true) setOf(TextStyle.Strikethrough) else emptySet()
+                it.dri == DRI("kotlin", "Deprecated")
+                        || it.dri == DRI("java.lang", "Deprecated")
+            } == true) setOf(TextStyle.Strikethrough) else emptySet()
 }
 
 sealed class AtStrategy
diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
index 3e92b902..28c26dea 100644
--- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
+++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.signatures
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
@@ -24,7 +25,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         ExtraModifiers.KotlinOnlyModifiers.TailRec,
         ExtraModifiers.KotlinOnlyModifiers.External
     )
-    private val platformSpecificModifiers : Map<ExtraModifiers, Set<Platform>> = mapOf(
+    private val platformSpecificModifiers: Map<ExtraModifiers, Set<Platform>> = mapOf(
         ExtraModifiers.KotlinOnlyModifiers.External to setOf(Platform.js)
     )
 
@@ -40,13 +41,14 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         )
     }
 
-    private fun <T> PageContentBuilder.DocumentableContentBuilder.processExtraModifiers (t: T)
-            where T: Documentable, T: WithExtraProperties<T> {
+    private fun <T> PageContentBuilder.DocumentableContentBuilder.processExtraModifiers(t: T)
+            where T : Documentable, T : WithExtraProperties<T> {
         sourceSetDependentText(
             t.modifiers()
                 .mapValues { entry ->
                     entry.value.filter {
-                        it !in ignoredExtraModifiers || entry.key.platform in (platformSpecificModifiers[it] ?: emptySet())
+                        it !in ignoredExtraModifiers || entry.key.analysisPlatform in (platformSpecificModifiers[it]
+                            ?: emptySet())
                     }
                 }
         ) {
@@ -73,7 +75,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             }
         }
 
-    private fun actualTypealiasedSignature(c: DClasslike, sourceSet: SourceSetData, aliasedType: Bound) =
+    private fun actualTypealiasedSignature(c: DClasslike, sourceSet: DokkaSourceSet, aliasedType: Bound) =
         contentBuilder.contentFor(
             c,
             ContentKind.Symbol,
@@ -97,7 +99,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         }
 
 
-    private fun regularSignature(c: DClasslike, sourceSet: SourceSetData) =
+    private fun regularSignature(c: DClasslike, sourceSet: DokkaSourceSet) =
         contentBuilder.contentFor(
             c,
             ContentKind.Symbol,
@@ -315,7 +317,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             is UnresolvedBound -> text(p.name)
         }
 
-    private fun funType(dri: DRI, sourceSets: Set<SourceSetData>, type: TypeConstructor) =
+    private fun funType(dri: DRI, sourceSets: Set<DokkaSourceSet>, type: TypeConstructor) =
         contentBuilder.contentFor(dri, sourceSets, ContentKind.Main) {
             if (type.extension) {
                 signatureForProjection(type.projections.first())
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt
index 27557107..109aa640 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DeprecatedDocumentableFilterTransformer.kt
@@ -8,18 +8,16 @@ import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransf
 
 class DeprecatedDocumentableFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
     override fun invoke(modules: List<DModule>) = modules.map { original ->
-        val passOptions = context.configuration.passesConfigurations.first {
-            original.sourceSets.contains(context.sourceSet(it))
-        }
+        val sourceSet = original.sourceSets.single()
         val packageOptions =
-            passOptions.perPackageOptions
+            sourceSet.perPackageOptions
         original.let {
-            DeprecatedDocumentableFilter(passOptions, packageOptions).processModule(it)
+            DeprecatedDocumentableFilter(sourceSet, packageOptions).processModule(it)
         }
     }
 
     private class DeprecatedDocumentableFilter(
-        val globalOptions: DokkaConfiguration.PassConfiguration,
+        val globalOptions: DokkaConfiguration.DokkaSourceSet,
         val packageOptions: List<DokkaConfiguration.PackageOptions>
     ) {
 
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
index 0a01680f..c3cc4d38 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
@@ -4,15 +4,13 @@ import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 
 class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
 
     override fun invoke(modules: List<DModule>) = modules.map { original ->
-        val passOptions = context.configuration.passesConfigurations.first {
-            original.sourceSets.contains(context.sourceSet(it))
-        }
-        val packageOptions =
-            passOptions.perPackageOptions
+        val passOptions = original.sourceSets.single()
+        val packageOptions = passOptions.perPackageOptions
         original.let {
             DocumentableVisibilityFilter(packageOptions, passOptions).processModule(it)
         }
@@ -20,7 +18,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
 
     private class DocumentableVisibilityFilter(
         val packageOptions: List<DokkaConfiguration.PackageOptions>,
-        val globalOptions: DokkaConfiguration.PassConfiguration
+        val globalOptions: DokkaSourceSet
     ) {
         fun Visibility.isAllowedInPackage(packageName: String?) = when (this) {
             is JavaVisibility.Public,
@@ -82,14 +80,14 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
             return Pair(packagesListChanged, filteredPackages)
         }
 
-        private fun <T : WithVisibility> alwaysTrue(a: T, p: SourceSetData) = true
-        private fun <T : WithVisibility> alwaysFalse(a: T, p: SourceSetData) = false
+        private fun <T : WithVisibility> alwaysTrue(a: T, p: DokkaSourceSet) = true
+        private fun <T : WithVisibility> alwaysFalse(a: T, p: DokkaSourceSet) = false
 
-        private fun WithVisibility.visibilityForPlatform(data: SourceSetData): Visibility? = visibility[data]
+        private fun WithVisibility.visibilityForPlatform(data: DokkaSourceSet): Visibility? = visibility[data]
 
         private fun <T> T.filterPlatforms(
-            additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue,
-            alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse
+            additionalCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysTrue,
+            alternativeCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysFalse
         ) where T : Documentable, T : WithVisibility =
             sourceSets.filter { d ->
                 visibilityForPlatform(d)?.isAllowedInPackage(dri.packageName) == true &&
@@ -98,9 +96,9 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
             }.toSet()
 
         private fun <T> List<T>.transform(
-            additionalCondition: (T, SourceSetData) -> Boolean = ::alwaysTrue,
-            alternativeCondition: (T, SourceSetData) -> Boolean = ::alwaysFalse,
-            recreate: (T, Set<SourceSetData>) -> T
+            additionalCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysTrue,
+            alternativeCondition: (T, DokkaSourceSet) -> Boolean = ::alwaysFalse,
+            recreate: (T, Set<DokkaSourceSet>) -> T
         ): Pair<Boolean, List<T>> where T : Documentable, T : WithVisibility {
             var changed = false
             val values = mapNotNull { t ->
@@ -122,7 +120,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
 
         private fun filterFunctions(
             functions: List<DFunction>,
-            additionalCondition: (DFunction, SourceSetData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DFunction, DokkaSourceSet) -> Boolean = ::alwaysTrue
         ) =
             functions.transform(additionalCondition) { original, filteredPlatforms ->
                 with(original) {
@@ -145,13 +143,13 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
                 }
             }
 
-        private fun hasVisibleAccessorsForPlatform(property: DProperty, data: SourceSetData) =
+        private fun hasVisibleAccessorsForPlatform(property: DProperty, data: DokkaSourceSet) =
             property.getter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true ||
                     property.setter?.visibilityForPlatform(data)?.isAllowedInPackage(property.dri.packageName) == true
 
         private fun filterProperties(
             properties: List<DProperty>,
-            additionalCondition: (DProperty, SourceSetData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DProperty, DokkaSourceSet) -> Boolean = ::alwaysTrue
         ): Pair<Boolean, List<DProperty>> =
             properties.transform(additionalCondition, ::hasVisibleAccessorsForPlatform) { original, filteredPlatforms ->
                 with(original) {
@@ -174,7 +172,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
                 }
             }
 
-        private fun filterEnumEntries(entries: List<DEnumEntry>, filteredPlatforms: Set<SourceSetData>) =
+        private fun filterEnumEntries(entries: List<DEnumEntry>, filteredPlatforms: Set<DokkaSourceSet>) =
             entries.mapNotNull { entry ->
                 if (filteredPlatforms.containsAll(entry.sourceSets)) entry
                 else {
@@ -196,7 +194,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
 
         private fun filterClasslikes(
             classlikeList: List<DClasslike>,
-            additionalCondition: (DClasslike, SourceSetData) -> Boolean = ::alwaysTrue
+            additionalCondition: (DClasslike, DokkaSourceSet) -> Boolean = ::alwaysTrue
         ): Pair<Boolean, List<DClasslike>> {
             var classlikesListChanged = false
             val filteredClasslikes: List<DClasslike> = classlikeList.mapNotNull {
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
index 6b29531c..3fd0081a 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
@@ -3,22 +3,18 @@ package org.jetbrains.dokka.base.transformers.documentables
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.model.DPackage
-import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 
 class EmptyPackagesFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
     override fun invoke(modules: List<DModule>): List<DModule> = modules.map { original ->
-        val passOptions = context.configuration.passesConfigurations.first {
-            original.sourceSets.contains(context.sourceSet(it))
-        }
         original.let {
-            EmptyPackagesFilter(passOptions).processModule(it)
+            EmptyPackagesFilter(original.sourceSets.single()).processModule(it)
         }
     }
 
     private class EmptyPackagesFilter(
-        val passOptions: DokkaConfiguration.PassConfiguration
+        val passOptions: DokkaConfiguration.DokkaSourceSet
     ) {
         fun DPackage.shouldBeSkipped() = passOptions.skipEmptyPackages &&
                 functions.isEmpty() &&
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
index 15ffc08a..f1bccd66 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/InheritorsExtractorTransformer.kt
@@ -5,13 +5,14 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.properties.ExtraProperty
 import org.jetbrains.dokka.model.properties.MergeStrategy
 import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.transformers.documentation.DocumentableTransformer
 
 class InheritorsExtractorTransformer : DocumentableTransformer {
     override fun invoke(original: DModule, context: DokkaContext): DModule =
         original.generateInheritanceMap().let { inheritanceMap -> original.appendInheritors(inheritanceMap) as DModule }
 
-    private fun <T : Documentable> T.appendInheritors(inheritanceMap: Map<SourceSetData, Map<DRI, List<DRI>>>): Documentable =
+    private fun <T : Documentable> T.appendInheritors(inheritanceMap: Map<DokkaSourceSet, Map<DRI, List<DRI>>>): Documentable =
         InheritorsInfo(inheritanceMap.getForDRI(dri)).let { info ->
             when (this) {
                 is DModule -> copy(packages = packages.map { it.appendInheritors(inheritanceMap) as DPackage })
@@ -45,7 +46,7 @@ class InheritorsExtractorTransformer : DocumentableTransformer {
 
     private fun InheritorsInfo.isNotEmpty() = this.value.values.fold(0) { acc, list -> acc + list.size } > 0
 
-    private fun Map<SourceSetData, Map<DRI, List<DRI>>>.getForDRI(dri: DRI) =
+    private fun Map<DokkaSourceSet, Map<DRI, List<DRI>>>.getForDRI(dri: DRI) =
         map { (v, k) ->
             v to k[dri]
         }.map { (k, v) -> k to v.orEmpty() }.toMap()
@@ -57,7 +58,7 @@ class InheritorsExtractorTransformer : DocumentableTransformer {
                     .groupBy({ it.first }) { it.second }.map { (k2, v2) -> k2 to v2.flatten() }.toMap()
             }.filter { it.second.values.isNotEmpty() }.toMap()
 
-    private fun <T : Documentable> T.getInheritanceEntriesRec(): List<Pair<SourceSetData, List<Pair<DRI, DRI>>>> =
+    private fun <T : Documentable> T.getInheritanceEntriesRec(): List<Pair<DokkaSourceSet, List<Pair<DRI, DRI>>>> =
         this.toInheritanceEntries() + children.flatMap { it.getInheritanceEntriesRec() }
 
     private fun <T : Documentable> T.toInheritanceEntries() =
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
index 63232793..1f718a7c 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
@@ -3,9 +3,8 @@ package org.jetbrains.dokka.base.transformers.documentables
 import org.jetbrains.dokka.analysis.EnvironmentAndFacade
 import org.jetbrains.dokka.analysis.KotlinAnalysis
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
-import org.jetbrains.dokka.model.sourceSet
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.parsers.MarkdownParser
 import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -23,9 +22,9 @@ internal class ModuleAndPackageDocumentationTransformer(
     override fun invoke(modules: List<DModule>): List<DModule> {
 
         val modulesAndPackagesDocumentation =
-            context.configuration.passesConfigurations
+            context.configuration.sourceSets
                 .map {
-                    Pair(it.moduleName, context.sourceSet(it)) to
+                    Pair(it.moduleName, it) to
                             it.includes.map { Paths.get(it) }
                                 .also {
                                     it.forEach {
@@ -101,7 +100,7 @@ internal class ModuleAndPackageDocumentationTransformer(
         }
     }
 
-    private fun mergeDocumentation(origin: Map<SourceSetData, DocumentationNode>, new: Map<SourceSetData, DocumentationNode>) =
+    private fun mergeDocumentation(origin: Map<DokkaSourceSet, DocumentationNode>, new: Map<DokkaSourceSet, DocumentationNode>) =
         (origin.asSequence() + new.asSequence())
             .distinct()
             .groupBy({ it.key }, { it.value })
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
index 0b47345d..2ebd4c62 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ReportUndocumentedTransformer.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.base.transformers.documentables
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaConfiguration.PassConfiguration
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -26,12 +26,11 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
     }
 
     private fun shouldBeReportedIfNotDocumented(
-        documentable: Documentable, sourceSet: SourceSetData, context: DokkaContext
+        documentable: Documentable, sourceSet: DokkaSourceSet, context: DokkaContext
     ): Boolean {
-        val passConfiguration = passConfiguration(context, sourceSet)
-        val packageOptionsOrNull = packageOptionsOrNull(passConfiguration, documentable)
+        val packageOptionsOrNull = packageOptionsOrNull(sourceSet, documentable)
 
-        if (!(packageOptionsOrNull?.reportUndocumented ?: passConfiguration.reportUndocumented)) {
+        if (!(packageOptionsOrNull?.reportUndocumented ?: sourceSet.reportUndocumented)) {
             return false
         }
 
@@ -61,7 +60,7 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
     private fun reportIfUndocumented(
         context: DokkaContext,
         documentable: Documentable,
-        sourceSet: SourceSetData
+        sourceSet: DokkaSourceSet
     ) {
         if (isUndocumented(documentable, sourceSet)) {
             val documentableDescription = with(documentable) {
@@ -94,14 +93,14 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
         }
     }
 
-    private fun isUndocumented(documentable: Documentable, sourceSet: SourceSetData): Boolean {
-        fun resolveDependentSourceSets(sourceSet: SourceSetData): List<SourceSetData> {
+    private fun isUndocumented(documentable: Documentable, sourceSet: DokkaSourceSet): Boolean {
+        fun resolveDependentSourceSets(sourceSet: DokkaSourceSet): List<DokkaSourceSet> {
             return sourceSet.dependentSourceSets.mapNotNull { sourceSetID ->
                 documentable.sourceSets.singleOrNull { it.sourceSetID == sourceSetID }
             }
         }
 
-        fun withAllDependentSourceSets(sourceSet: SourceSetData): Sequence<SourceSetData> {
+        fun withAllDependentSourceSets(sourceSet: DokkaSourceSet): Sequence<DokkaSourceSet> {
             return sequence {
                 yield(sourceSet)
                 for (dependentSourceSet in resolveDependentSourceSets(sourceSet)) {
@@ -120,25 +119,16 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
         return documentable.isConstructor
     }
 
-    private fun passConfiguration(context: DokkaContext, sourceSet: SourceSetData): PassConfiguration {
-        val passes = context.configuration.passesConfigurations.filter { configuration ->
-            configuration.sourceSetID == sourceSet.sourceSetID
-        }
-        if (passes.size > 1)
-            context.logger.error("Expected one passConfiguration with ID: ${sourceSet.sourceSetID} found: ${passes.size} in [${passes.joinToString { it.moduleName }}]")
-        return passes.first()
-    }
-
-    private fun isFakeOverride(documentable: Documentable, sourceSet: SourceSetData): Boolean {
+    private fun isFakeOverride(documentable: Documentable, sourceSet: DokkaSourceSet): Boolean {
         return callableMemberDescriptorOrNull(documentable, sourceSet)?.kind == FAKE_OVERRIDE
     }
 
-    private fun isSynthesized(documentable: Documentable, sourceSet: SourceSetData): Boolean {
+    private fun isSynthesized(documentable: Documentable, sourceSet: DokkaSourceSet): Boolean {
         return callableMemberDescriptorOrNull(documentable, sourceSet)?.kind == SYNTHESIZED
     }
 
     private fun callableMemberDescriptorOrNull(
-        documentable: Documentable, sourceSet: SourceSetData
+        documentable: Documentable, sourceSet: DokkaSourceSet
     ): CallableMemberDescriptor? {
         if (documentable is WithExpectActual) {
             return documentable.sources[sourceSet]
@@ -149,7 +139,7 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
         return null
     }
 
-    private fun isPrivateOrInternalApi(documentable: Documentable, sourceSet: SourceSetData): Boolean {
+    private fun isPrivateOrInternalApi(documentable: Documentable, sourceSet: DokkaSourceSet): Boolean {
         return when (documentable.safeAs<WithVisibility>()?.visibility?.get(sourceSet)) {
             KotlinVisibility.Public -> false
             KotlinVisibility.Private -> true
@@ -164,11 +154,11 @@ internal class ReportUndocumentedTransformer : DocumentableTransformer {
     }
 
     private fun packageOptionsOrNull(
-        passConfiguration: PassConfiguration,
+        dokkaSourceSet: DokkaSourceSet,
         documentable: Documentable
     ): DokkaConfiguration.PackageOptions? {
         val packageName = documentable.dri.packageName ?: return null
-        return passConfiguration.perPackageOptions
+        return dokkaSourceSet.perPackageOptions
             .filter { packageOptions -> packageName.startsWith(packageOptions.prefix) }
             .maxBy { packageOptions -> packageOptions.prefix.length }
     }
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
index cb74441e..fa9ce37e 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/CommentsToContentConverter.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.base.transformers.pages.comments
 
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -9,7 +9,7 @@ interface CommentsToContentConverter {
     fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        platforms: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         styles: Set<Style> = emptySet(),
         extras: PropertyContainer<ContentNode> = PropertyContainer.empty()
     ): List<ContentNode>
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
index be1217db..14f3a996 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
@@ -1,6 +1,6 @@
 package org.jetbrains.dokka.base.transformers.pages.comments
 
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.doc.*
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -9,7 +9,7 @@ object DocTagToContentConverter : CommentsToContentConverter {
     override fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        sourceSets: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         styles: Set<Style>,
         extra: PropertyContainer<ContentNode>
     ): List<ContentNode> {
diff --git a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
index 0d133a65..a40f2f53 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
@@ -8,10 +8,9 @@ import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.analysis.EnvironmentAndFacade
 import org.jetbrains.dokka.base.renderers.platforms
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.doc.Sample
 import org.jetbrains.dokka.model.properties.PropertyContainer
-import org.jetbrains.dokka.model.sourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.pages.PageTransformer
@@ -40,8 +39,8 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         }
     }
 
-    private fun setUpAnalysis(context: DokkaContext) = context.configuration.passesConfigurations.map {
-        context.sourceSet(it) to AnalysisEnvironment(DokkaMessageCollector(context.logger), it.analysisPlatform).run {
+    private fun setUpAnalysis(context: DokkaContext) = context.configuration.sourceSets.map {
+        it to AnalysisEnvironment(DokkaMessageCollector(context.logger), it.analysisPlatform).run {
             if (analysisPlatform == Platform.jvm) {
                 addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
             }
@@ -59,9 +58,9 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
 
     private fun ContentNode.addSample(
         contentPage: ContentPage,
-        platform: SourceSetData,
+        platform: DokkaSourceSet,
         fqName: String,
-        analysis: Map<SourceSetData, EnvironmentAndFacade>
+        analysis: Map<DokkaSourceSet, EnvironmentAndFacade>
     ): ContentNode {
         val facade = analysis[platform]?.facade
             ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleName}") }
@@ -110,7 +109,7 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         return DescriptorToSourceUtils.descriptorToDeclaration(symbol)
     }
 
-    private fun contentCode(sourceSets: List<SourceSetData>, dri: Set<DRI>, content: String, language: String) =
+    private fun contentCode(sourceSets: List<DokkaSourceSet>, dri: Set<DRI>, content: String, language: String) =
         ContentCode(
             children = listOf(
                 ContentText(
diff --git a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
index 7603c80b..42422934 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/sourcelinks/SourceLinksTransformer.kt
@@ -3,11 +3,11 @@ package org.jetbrains.dokka.base.transformers.pages.sourcelinks
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
-import org.jetbrains.dokka.analysis.PsiDocumentableSource
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.DocumentableSource
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
+import org.jetbrains.dokka.analysis.DescriptorDocumentableSource
+import org.jetbrains.dokka.analysis.PsiDocumentableSource
 import org.jetbrains.dokka.model.WithExpectActual
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
@@ -29,8 +29,8 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
             }
         }
 
-    private fun getSourceLinks() = context.configuration.passesConfigurations
-        .flatMap { it.sourceLinks.map { sl -> SourceLink(sl, context.sourceSetCache.getSourceSet(it)) } }
+    private fun getSourceLinks() = context.configuration.sourceSets
+        .flatMap { it.sourceLinks.map { sl -> SourceLink(sl, it) } }
 
     private fun resolveSources(documentable: WithExpectActual) = documentable.sources
         .mapNotNull { entry ->
@@ -42,7 +42,7 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
             }
         }
 
-    private fun ContentPage.addSourcesContent(sources: List<Pair<SourceSetData, String>>) = builder
+    private fun ContentPage.addSourcesContent(sources: List<Pair<DokkaSourceSet, String>>) = builder
         .buildSourcesContent(this, sources)
         .let {
             this.modified(
@@ -52,7 +52,7 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
 
     private fun PageContentBuilder.buildSourcesContent(
         node: ContentPage,
-        sources: List<Pair<SourceSetData, String>>
+        sources: List<Pair<DokkaSourceSet, String>>
     ) = contentFor(
         node.dri.first(),
         node.documentable!!.sourceSets.toSet()
@@ -121,8 +121,8 @@ class SourceLinksTransformer(val context: DokkaContext, val builder: PageContent
     }
 }
 
-data class SourceLink(val path: String, val url: String, val lineSuffix: String?, val sourceSetData: SourceSetData) {
-    constructor(sourceLinkDefinition: DokkaConfiguration.SourceLinkDefinition, sourceSetData: SourceSetData) : this(
+data class SourceLink(val path: String, val url: String, val lineSuffix: String?, val sourceSetData: DokkaSourceSet) {
+    constructor(sourceLinkDefinition: DokkaConfiguration.SourceLinkDefinition, sourceSetData: DokkaSourceSet) : this(
         sourceLinkDefinition.path, sourceLinkDefinition.url, sourceLinkDefinition.lineSuffix, sourceSetData
     )
 }
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index cefea4ec..9cdd251c 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.translators.descriptors
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.analysis.*
 import org.jetbrains.dokka.links.*
 import org.jetbrains.dokka.links.Callable
@@ -50,13 +51,12 @@ import org.jetbrains.kotlin.resolve.constants.AnnotationValue as ConstantsAnnota
 import org.jetbrains.kotlin.resolve.constants.ArrayValue as ConstantsArrayValue
 import org.jetbrains.kotlin.resolve.constants.EnumValue as ConstantsEnumValue
 import org.jetbrains.kotlin.resolve.constants.KClassValue as ConstantsKtClassValue
-import kotlin.IllegalArgumentException
 
 class DefaultDescriptorToDocumentableTranslator(
     private val kotlinAnalysis: KotlinAnalysis
 ) : SourceToDocumentableTranslator {
 
-    override fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule {
+    override fun invoke(sourceSet: DokkaSourceSet, context: DokkaContext): DModule {
         val (environment, facade) = kotlinAnalysis[sourceSet]
         val packageFragments = environment.getSourceFiles().asSequence()
             .map { it.packageFqName }
@@ -83,7 +83,7 @@ data class DRIWithPlatformInfo(
 fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, emptyMap())
 
 private class DokkaDescriptorVisitor(
-    private val sourceSet: SourceSetData,
+    private val sourceSet: DokkaSourceSet,
     private val resolutionFacade: DokkaResolutionFacade,
     private val logger: DokkaLogger
 ) : DeclarationDescriptorVisitorEmptyBodies<Documentable, DRIWithPlatformInfo>() {
@@ -729,11 +729,11 @@ private class DokkaDescriptorVisitor(
 
     private fun KtInitializerList.initializersAsText() =
         initializers.firstIsInstanceOrNull<KtCallElement>()
-        ?.getValueArgumentsInParentheses()
-        ?.flatMap { it.childrenAsText() }
-        .orEmpty()
+            ?.getValueArgumentsInParentheses()
+            ?.flatMap { it.childrenAsText() }
+            .orEmpty()
 
-    private fun ValueArgument.childrenAsText() = this.safeAs<KtValueArgument>()?.children?.map {it.text }.orEmpty()
+    private fun ValueArgument.childrenAsText() = this.safeAs<KtValueArgument>()?.children?.map { it.text }.orEmpty()
 
     private data class ClassInfo(val superclasses: List<DRI>, val interfaces: List<DRI>, val docs: SourceSetDependent<DocumentationNode>){
         val supertypes: List<DRI>
@@ -751,11 +751,12 @@ private class DokkaDescriptorVisitor(
     private fun ConstantsEnumValue.fullEnumEntryName() =
         "${this.enumClassId.relativeClassName.asString()}.${this.enumEntryName.identifier}"
 
-    private fun fallbackPackageName(): String = "[${sourceSet.displayName} root]"// TODO: error-prone, find a better way to do it
+    private fun fallbackPackageName(): String =
+        "[${sourceSet.displayName} root]"// TODO: error-prone, find a better way to do it
 }
 
 private fun DRI.withPackageFallbackTo(fallbackPackage: String): DRI {
-    return if(packageName.isNullOrBlank()){
+    return if (packageName.isNullOrBlank()) {
         copy(packageName = fallbackPackage)
     } else {
         this
diff --git a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
index 3fa950ed..c94b1814 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka.base.translators.documentables
 
+import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.signatures.SignatureProvider
 import org.jetbrains.dokka.base.transformers.documentables.InheritorsInfo
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
@@ -14,8 +15,9 @@ import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import kotlin.reflect.KClass
 import kotlin.reflect.full.isSubclassOf
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 
-private typealias GroupedTags = Map<KClass<out TagWrapper>, List<Pair<SourceSetData?, TagWrapper>>>
+private typealias GroupedTags = Map<KClass<out TagWrapper>, List<Pair<DokkaSourceSet?, TagWrapper>>>
 
 private val specialTags: Set<KClass<out TagWrapper>> =
     setOf(Property::class, Description::class, Constructor::class, Receiver::class, Param::class, See::class)
@@ -71,8 +73,13 @@ open class DefaultPageCreator(
     protected open fun contentForModule(m: DModule) = contentBuilder.contentFor(m) {
         group(kind = ContentKind.Cover) {
             cover(m.name)
-            if(contentForDescription(m).isNotEmpty()){
-                sourceSetDependentHint(m.dri, m.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = setOf(TextStyle.UnderCoverText)){
+            if (contentForDescription(m).isNotEmpty()) {
+                sourceSetDependentHint(
+                    m.dri,
+                    m.sourceSets.toSet(),
+                    kind = ContentKind.SourceSetDependantHint,
+                    styles = setOf(TextStyle.UnderCoverText)
+                ) {
                     +contentForDescription(m)
                 }
             }
@@ -88,13 +95,18 @@ open class DefaultPageCreator(
     protected open fun contentForPackage(p: DPackage) = contentBuilder.contentFor(p) {
         group(kind = ContentKind.Cover) {
             cover("Package ${p.name}")
-            if(contentForDescription(p).isNotEmpty()){
-                sourceSetDependentHint(p.dri, p.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = setOf(TextStyle.UnderCoverText)){
+            if (contentForDescription(p).isNotEmpty()) {
+                sourceSetDependentHint(
+                    p.dri,
+                    p.sourceSets.toSet(),
+                    kind = ContentKind.SourceSetDependantHint,
+                    styles = setOf(TextStyle.UnderCoverText)
+                ) {
                     +contentForDescription(p)
                 }
             }
         }
-        group(styles = setOf(ContentStyle.TabbedContent)){
+        group(styles = setOf(ContentStyle.TabbedContent)) {
             +contentForComments(p)
             +contentForScope(p, p.dri, p.sourceSets)
         }
@@ -103,15 +115,27 @@ open class DefaultPageCreator(
     protected open fun contentForScope(
         s: WithScope,
         dri: DRI,
-        sourceSets: Set<SourceSetData>
+        sourceSets: Set<DokkaSourceSet>
     ) = contentBuilder.contentFor(s as Documentable) {
         val types = listOf(
             s.classlikes,
             (s as? DPackage)?.typealiases ?: emptyList()
         ).flatten()
         divergentBlock("Types", types, ContentKind.Classlikes, extra = mainExtra + SimpleAttr.header("Types"))
-        divergentBlock("Functions", s.functions, ContentKind.Functions, extra = mainExtra + SimpleAttr.header( "Functions"))
-        block("Properties", 2, ContentKind.Properties, s.properties, sourceSets.toSet(), extra = mainExtra + SimpleAttr.header( "Properties")) {
+        divergentBlock(
+            "Functions",
+            s.functions,
+            ContentKind.Functions,
+            extra = mainExtra + SimpleAttr.header("Functions")
+        )
+        block(
+            "Properties",
+            2,
+            ContentKind.Properties,
+            s.properties,
+            sourceSets.toSet(),
+            extra = mainExtra + SimpleAttr.header("Properties")
+        ) {
             link(it.name, it.dri, kind = ContentKind.Main)
             sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                 contentForBrief(it)
@@ -136,7 +160,7 @@ open class DefaultPageCreator(
                     DCI(setOf(dri), ContentKind.Inheritors),
                     sourceSets.toSet(),
                     style = emptySet(),
-                    extra = mainExtra + SimpleAttr.header( "Inheritors")
+                    extra = mainExtra + SimpleAttr.header("Inheritors")
                 )
             }
         }
@@ -150,7 +174,7 @@ open class DefaultPageCreator(
                 +buildSignature(e)
             }
         }
-        group(styles = setOf(ContentStyle.TabbedContent)){
+        group(styles = setOf(ContentStyle.TabbedContent)) {
             +contentForComments(e)
             +contentForScope(e, e.dri, e.sourceSets)
         }
@@ -177,14 +201,28 @@ open class DefaultPageCreator(
                     extra = PropertyContainer.empty<ContentNode>() + SimpleAttr.header("Constructors")
                 ) {
                     link(it.name, it.dri, kind = ContentKind.Main)
-                    sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint, styles = emptySet()) {
+                    sourceSetDependentHint(
+                        it.dri,
+                        it.sourceSets.toSet(),
+                        kind = ContentKind.SourceSetDependantHint,
+                        styles = emptySet()
+                    ) {
                         contentForBrief(it)
                         +buildSignature(it)
                     }
                 }
             }
             if (c is DEnum) {
-                block("Entries", 2, ContentKind.Classlikes, c.entries, c.sourceSets.toSet(), needsSorting = false, extra = mainExtra + SimpleAttr.header("Entries"), styles = emptySet()) {
+                block(
+                    "Entries",
+                    2,
+                    ContentKind.Classlikes,
+                    c.entries,
+                    c.sourceSets.toSet(),
+                    needsSorting = false,
+                    extra = mainExtra + SimpleAttr.header("Entries"),
+                    styles = emptySet()
+                ) {
                     link(it.name, it.dri)
                     sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependantHint) {
                         contentForBrief(it)
@@ -198,11 +236,11 @@ open class DefaultPageCreator(
 
     @Suppress("UNCHECKED_CAST")
     private inline fun <reified T : TagWrapper> GroupedTags.withTypeUnnamed(): SourceSetDependent<T> =
-        (this[T::class] as List<Pair<SourceSetData, T>>?)?.toMap().orEmpty()
+        (this[T::class] as List<Pair<DokkaSourceSet, T>>?)?.toMap().orEmpty()
 
     @Suppress("UNCHECKED_CAST")
     private inline fun <reified T : NamedTagWrapper> GroupedTags.withTypeNamed(): Map<String, SourceSetDependent<T>> =
-        (this[T::class] as List<Pair<SourceSetData, T>>?)
+        (this[T::class] as List<Pair<DokkaSourceSet, T>>?)
             ?.groupBy { it.second.name }
             ?.mapValues { (_, v) -> v.toMap() }
             ?.toSortedMap(String.CASE_INSENSITIVE_ORDER)
@@ -234,8 +272,8 @@ open class DefaultPageCreator(
 
             val unnamedTags: List<SourceSetDependent<TagWrapper>> =
                 tags.filterNot { (k, _) -> k.isSubclassOf(NamedTagWrapper::class) || k in specialTags }
-                    .map { (_, v) -> v.mapNotNull { (k,v) -> k?.let { it to v } }.toMap() }
-            if(unnamedTags.isNotEmpty()){
+                    .map { (_, v) -> v.mapNotNull { (k, v) -> k?.let { it to v } }.toMap() }
+            if (unnamedTags.isNotEmpty()) {
                 platforms.forEach { platform ->
                     unnamedTags.forEach { pdTag ->
                         pdTag[platform]?.also { tag ->
@@ -252,10 +290,10 @@ open class DefaultPageCreator(
         }.children
     }
 
-    private fun Documentable.getPossibleFallbackSourcesets(sourceSet: SourceSetData) =
+    private fun Documentable.getPossibleFallbackSourcesets(sourceSet: DokkaSourceSet) =
         this.sourceSets.filter { it.sourceSetID in sourceSet.dependentSourceSets }
 
-    private fun <V> Map<SourceSetData, V>.fallback(sourceSets: List<SourceSetData>) : V? =
+    private fun <V> Map<DokkaSourceSet, V>.fallback(sourceSets: List<DokkaSourceSet>): V? =
         sourceSets.firstOrNull { it in this.keys }.let { this[it] }
 
     protected open fun contentForComments(
@@ -270,7 +308,10 @@ open class DefaultPageCreator(
         fun DocumentableContentBuilder.contentForParams() {
             if (tags.isNotEmptyForTag<Param>()) {
                 header(2, "Parameters")
-                group(extra = mainExtra + SimpleAttr.header("Parameters"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                group(
+                    extra = mainExtra + SimpleAttr.header("Parameters"),
+                    styles = setOf(ContentStyle.WithExtraAttributes)
+                ) {
                     sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
                         val receiver = tags.withTypeUnnamed<Receiver>()
                         val params = tags.withTypeNamed<Param>()
@@ -287,7 +328,11 @@ open class DefaultPageCreator(
                                 val paramRows = params.mapNotNull { (_, param) ->
                                     (param[platform] ?: param.fallback(possibleFallbacks))?.let {
                                         buildGroup(sourceSets = setOf(platform), kind = ContentKind.Parameters) {
-                                            text(it.name, kind = ContentKind.Parameters, styles = mainStyles + ContentStyle.RowTitle)
+                                            text(
+                                                it.name,
+                                                kind = ContentKind.Parameters,
+                                                styles = mainStyles + ContentStyle.RowTitle
+                                            )
                                             comment(it.root)
                                         }
                                     }
@@ -304,7 +349,10 @@ open class DefaultPageCreator(
         fun DocumentableContentBuilder.contentForSeeAlso() {
             if (tags.isNotEmptyForTag<See>()) {
                 header(2, "See also")
-                group(extra = mainExtra + SimpleAttr.header("See also"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                group(
+                    extra = mainExtra + SimpleAttr.header("See also"),
+                    styles = setOf(ContentStyle.WithExtraAttributes)
+                ) {
                     sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
                         val seeAlsoTags = tags.withTypeNamed<See>()
                         table(kind = ContentKind.Sample) {
@@ -312,8 +360,16 @@ open class DefaultPageCreator(
                                 val possibleFallbacks = d.getPossibleFallbackSourcesets(platform)
                                 seeAlsoTags.mapNotNull { (_, see) ->
                                     (see[platform] ?: see.fallback(possibleFallbacks))?.let {
-                                        buildGroup(sourceSets = setOf(platform), kind = ContentKind.Comment, styles = mainStyles + ContentStyle.RowTitle) {
-                                            if (it.address != null) link(it.name, it.address!!, kind = ContentKind.Comment)
+                                        buildGroup(
+                                            sourceSets = setOf(platform),
+                                            kind = ContentKind.Comment,
+                                            styles = mainStyles + ContentStyle.RowTitle
+                                        ) {
+                                            if (it.address != null) link(
+                                                it.name,
+                                                it.address!!,
+                                                kind = ContentKind.Comment
+                                            )
                                             else text(it.name, kind = ContentKind.Comment)
                                             comment(it.root)
                                         }
@@ -330,11 +386,18 @@ open class DefaultPageCreator(
             val samples = tags.withTypeNamed<Sample>()
             if (samples.isNotEmpty()) {
                 header(2, "Samples")
-                group(extra = mainExtra + SimpleAttr.header("Samples"), styles = setOf(ContentStyle.WithExtraAttributes)){
+                group(
+                    extra = mainExtra + SimpleAttr.header("Samples"),
+                    styles = setOf(ContentStyle.WithExtraAttributes)
+                ) {
                     sourceSetDependentHint(sourceSets = platforms.toSet(), kind = ContentKind.SourceSetDependantHint) {
                         platforms.map { platformData ->
                             val content = samples.filter { it.value.isEmpty() || platformData in it.value }
-                            group(sourceSets = setOf(platformData), kind = ContentKind.Sample, styles = setOf(TextStyle.Monospace)) {
+                            group(
+                                sourceSets = setOf(platformData),
+                                kind = ContentKind.Sample,
+                                styles = setOf(TextStyle.Monospace)
+                            ) {
                                 content.forEach {
                                     text(it.key)
                                 }
@@ -413,29 +476,33 @@ open class DefaultPageCreator(
                     .mapValues { if (it.value.any { it is DClasslike }) it.value.filter { it !is DTypeAlias } else it.value }
                     .toSortedMap(compareBy(nullsLast(String.CASE_INSENSITIVE_ORDER)){it})
                     .map { (elementName, elements) -> // This groupBy should probably use LocationProvider
-                    buildGroup(elements.map { it.dri }.toSet(), elements.flatMap { it.sourceSets }.toSet(), kind = kind) {
-                        link(elementName.orEmpty(), elements.first().dri, kind = kind)
-                        divergentGroup(
-                            ContentDivergentGroup.GroupID(name),
+                        buildGroup(
                             elements.map { it.dri }.toSet(),
+                            elements.flatMap { it.sourceSets }.toSet(),
                             kind = kind
                         ) {
-                            elements.map {
-                                instance(setOf(it.dri), it.sourceSets.toSet()) {
-                                    before {
-                                        contentForBrief(it)
-                                        contentForSinceKotlin(it)
-                                    }
-                                    divergent {
-                                        group {
-                                            +buildSignature(it)
+                            link(elementName.orEmpty(), elements.first().dri, kind = kind)
+                            divergentGroup(
+                                ContentDivergentGroup.GroupID(name),
+                                elements.map { it.dri }.toSet(),
+                                kind = kind
+                            ) {
+                                elements.map {
+                                    instance(setOf(it.dri), it.sourceSets.toSet()) {
+                                        before {
+                                            contentForBrief(it)
+                                            contentForSinceKotlin(it)
+                                        }
+                                        divergent {
+                                            group {
+                                                +buildSignature(it)
+                                            }
                                         }
                                     }
                                 }
                             }
                         }
                     }
-                }
             }
         }
     }
diff --git a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
index 9d10620e..a58ef114 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
@@ -1,9 +1,11 @@
 package org.jetbrains.dokka.base.translators.documentables
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.signatures.SignatureProvider
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Documentable
+import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -19,7 +21,7 @@ open class PageContentBuilder(
 ) {
     fun contentFor(
         dri: DRI,
-        sourceSets: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         kind: Kind = ContentKind.Main,
         styles: Set<Style> = emptySet(),
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
@@ -31,7 +33,7 @@ open class PageContentBuilder(
 
     fun contentFor(
         dri: Set<DRI>,
-        sourceSets: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         kind: Kind = ContentKind.Main,
         styles: Set<Style> = emptySet(),
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
@@ -46,7 +48,7 @@ open class PageContentBuilder(
         kind: Kind = ContentKind.Main,
         styles: Set<Style> = emptySet(),
         extra: PropertyContainer<ContentNode> = PropertyContainer.empty(),
-        sourceSets: Set<SourceSetData> = d.sourceSets.toSet(),
+        sourceSets: Set<DokkaSourceSet> = d.sourceSets.toSet(),
         block: DocumentableContentBuilder.() -> Unit = {}
     ): ContentGroup =
         DocumentableContentBuilder(setOf(d.dri), sourceSets, styles, extra)
@@ -56,14 +58,14 @@ open class PageContentBuilder(
     @ContentBuilderMarker
     open inner class DocumentableContentBuilder(
         val mainDRI: Set<DRI>,
-        val mainPlatformData: Set<SourceSetData>,
+        val mainPlatformData: Set<DokkaSourceSet>,
         val mainStyles: Set<Style>,
         val mainExtra: PropertyContainer<ContentNode>
     ) {
         protected val contents = mutableListOf<ContentNode>()
 
         fun build(
-            sourceSets: Set<SourceSetData>,
+            sourceSets: Set<DokkaSourceSet>,
             kind: Kind,
             styles: Set<Style>,
             extra: PropertyContainer<ContentNode>
@@ -87,7 +89,7 @@ open class PageContentBuilder(
             level: Int,
             text: String,
             kind: Kind = ContentKind.Main,
-            platformData: Set<SourceSetData> = mainPlatformData,
+            platformData: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit = {}
@@ -109,18 +111,18 @@ open class PageContentBuilder(
 
         fun cover(
             text: String,
-            platformData: Set<SourceSetData> = mainPlatformData,
+            platformData: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles + TextStyle.Cover,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit = {}
-            ) {
+        ) {
             header(1, text, platformData = platformData, styles = styles, extra = extra, block = block)
         }
 
         fun text(
             text: String,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
@@ -132,7 +134,7 @@ open class PageContentBuilder(
         fun linkTable(
             elements: List<DRI>,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
@@ -150,7 +152,7 @@ open class PageContentBuilder(
 
         fun table(
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             operation: DocumentableContentBuilder.() -> List<ContentGroup>
@@ -168,7 +170,7 @@ open class PageContentBuilder(
             level: Int,
             kind: Kind = ContentKind.Main,
             elements: Iterable<T>,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             renderWhenEmpty: Boolean = false,
@@ -180,16 +182,16 @@ open class PageContentBuilder(
                 contents += ContentTable(
                     emptyList(),
                     elements
-                        .let{
+                        .let {
                             if (needsSorting)
-                                it.sortedWith(compareBy(nullsLast(String.CASE_INSENSITIVE_ORDER)){ it.name })
+                                it.sortedWith(compareBy(nullsLast(String.CASE_INSENSITIVE_ORDER)) { it.name })
                             else it
                         }
                         .map {
-                        buildGroup(setOf(it.dri), it.sourceSets.toSet(), kind, styles, extra) {
-                            operation(it)
-                        }
-                    },
+                            buildGroup(setOf(it.dri), it.sourceSets.toSet(), kind, styles, extra) {
+                                operation(it)
+                            }
+                        },
                     DCI(mainDRI, kind),
                     sourceSets, styles, extra
                 )
@@ -201,7 +203,7 @@ open class PageContentBuilder(
             prefix: String = "",
             suffix: String = "",
             separator: String = ", ",
-            sourceSets: Set<SourceSetData> = mainPlatformData, // TODO: children should be aware of this platform data
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData, // TODO: children should be aware of this platform data
             operation: DocumentableContentBuilder.(T) -> Unit
         ) {
             if (elements.isNotEmpty()) {
@@ -219,7 +221,7 @@ open class PageContentBuilder(
             text: String,
             address: DRI,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
@@ -230,7 +232,7 @@ open class PageContentBuilder(
             text: String,
             address: DRI,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) = ContentDRILink(
@@ -244,7 +246,7 @@ open class PageContentBuilder(
             text: String,
             address: String,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) =
@@ -260,7 +262,7 @@ open class PageContentBuilder(
         fun link(
             address: DRI,
             kind: Kind = ContentKind.Main,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
             block: DocumentableContentBuilder.() -> Unit
@@ -276,7 +278,7 @@ open class PageContentBuilder(
         fun comment(
             docTag: DocTag,
             kind: Kind = ContentKind.Comment,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) {
@@ -290,7 +292,7 @@ open class PageContentBuilder(
 
         fun group(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -316,7 +318,7 @@ open class PageContentBuilder(
 
         fun buildGroup(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -325,7 +327,7 @@ open class PageContentBuilder(
 
         fun sourceSetDependentHint(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainPlatformData,
+            sourceSets: Set<DokkaSourceSet> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -339,7 +341,7 @@ open class PageContentBuilder(
 
         fun sourceSetDependentHint(
             dri: DRI,
-            platformData: Set<SourceSetData> = mainPlatformData,
+            platformData: Set<DokkaSourceSet> = mainPlatformData,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -354,7 +356,7 @@ open class PageContentBuilder(
         protected fun createText(
             text: String,
             kind: Kind,
-            sourceSets: Set<SourceSetData>,
+            sourceSets: Set<DokkaSourceSet>,
             styles: Set<Style>,
             extra: PropertyContainer<ContentNode>
         ) =
@@ -362,7 +364,7 @@ open class PageContentBuilder(
 
         fun <T> sourceSetDependentText(
             value: SourceSetDependent<T>,
-            sourceSets: Set<SourceSetData> = value.keys,
+            sourceSets: Set<DokkaSourceSet> = value.keys,
             transform: (T) -> String
         ) = value.entries.filter { it.key in sourceSets }.mapNotNull { (p, v) ->
             transform(v).takeIf { it.isNotBlank() }?.let { it to p }
@@ -381,7 +383,7 @@ open class PageContentBuilder(
         private val instances: MutableList<ContentDivergentInstance> = mutableListOf()
         fun instance(
             dri: Set<DRI>,
-            sourceSets: Set<SourceSetData>,  // Having correct PlatformData is crucial here, that's why there's no default
+            sourceSets: Set<DokkaSourceSet>,  // Having correct PlatformData is crucial here, that's why there's no default
             kind: Kind = mainKind,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -411,7 +413,7 @@ open class PageContentBuilder(
     @ContentBuilderMarker
     open inner class DivergentInstanceBuilder(
         private val mainDRI: Set<DRI>,
-        private val mainSourceSets: Set<SourceSetData>,
+        private val mainSourceSets: Set<DokkaSourceSet>,
         private val mainStyles: Set<Style>,
         private val mainExtra: PropertyContainer<ContentNode>
     ) {
@@ -421,7 +423,7 @@ open class PageContentBuilder(
 
         fun before(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainSourceSets,
+            sourceSets: Set<DokkaSourceSet> = mainSourceSets,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -434,7 +436,7 @@ open class PageContentBuilder(
 
         fun divergent(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainSourceSets,
+            sourceSets: Set<DokkaSourceSet> = mainSourceSets,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -445,7 +447,7 @@ open class PageContentBuilder(
 
         fun after(
             dri: Set<DRI> = mainDRI,
-            sourceSets: Set<SourceSetData> = mainSourceSets,
+            sourceSets: Set<DokkaSourceSet> = mainSourceSets,
             kind: Kind = ContentKind.Main,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra,
@@ -459,7 +461,7 @@ open class PageContentBuilder(
 
         fun build(
             kind: Kind,
-            sourceSets: Set<SourceSetData> = mainSourceSets,
+            sourceSets: Set<DokkaSourceSet> = mainSourceSets,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ) =
diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
index e71d936a..8588534b 100644
--- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
@@ -7,10 +7,10 @@ import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.*
 import com.intellij.psi.impl.source.PsiClassReferenceType
 import com.intellij.psi.impl.source.PsiImmediateClassType
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.analysis.KotlinAnalysis
 import org.jetbrains.dokka.analysis.PsiDocumentableSource
 import org.jetbrains.dokka.analysis.from
-import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.nextTarget
 import org.jetbrains.dokka.links.withClass
@@ -21,7 +21,6 @@ import org.jetbrains.dokka.model.doc.Param
 import org.jetbrains.dokka.model.doc.Text
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.transformers.sources.SourceToDocumentableTranslator
 import org.jetbrains.dokka.utilities.DokkaLogger
 import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
@@ -42,7 +41,7 @@ class DefaultPsiToDocumentableTranslator(
     private val kotlinAnalysis: KotlinAnalysis
 ) : SourceToDocumentableTranslator {
 
-    override fun invoke(sourceSet: SourceSetData, context: DokkaContext): DModule {
+    override fun invoke(sourceSet: DokkaSourceSet, context: DokkaContext): DModule {
 
         fun isFileInSourceRoots(file: File): Boolean {
             return sourceSet.sourceRoots.any { root -> file.path.startsWith(File(root.path).absolutePath) }
@@ -93,7 +92,7 @@ class DefaultPsiToDocumentableTranslator(
     }
 
     class DokkaPsiParser(
-        private val sourceSetData: SourceSetData,
+        private val sourceSetData: DokkaSourceSet,
         private val logger: DokkaLogger
     ) {
 
@@ -187,7 +186,7 @@ class DefaultPsiToDocumentableTranslator(
                     fields.filterIsInstance<PsiEnumConstant>().map { entry ->
                         DEnumEntry(
                             dri.withClass("$name.${entry.name}"),
-                            entry.name.orEmpty(),
+                            entry.name,
                             javadocParser.parseDocumentation(entry).toSourceSetDependent(),
                             null,
                             emptyList(),
diff --git a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
index f66f88db..2e05d241 100644
--- a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
+++ b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
@@ -3,8 +3,6 @@ package content.params
 import matchers.content.*
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.model.DFunction
-import org.jetbrains.dokka.model.Documentable
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.doc.Param
 import org.jetbrains.dokka.model.doc.Text
@@ -570,7 +568,7 @@ class ContentForParamsTest : AbstractCoreTest() {
     }
 
     @Test
-    fun javaDocCommentWithDocumentedParameters(){
+    fun javaDocCommentWithDocumentedParameters() {
         testInline(
             """
             |/src/main/java/test/Main.java
@@ -587,14 +585,14 @@ class ContentForParamsTest : AbstractCoreTest() {
             |   }
             | }
         """.trimIndent(), testConfiguration
-        ){
-            pagesTransformationStage = {
-                module ->
+        ) {
+            pagesTransformationStage = { module ->
                 val sampleFunction = module.dfs {
-                    it is MemberPageNode && it.dri.first().toString() == "test/Main/sample/#java.lang.String#java.lang.String/PointingToDeclaration/"
+                    it is MemberPageNode && it.dri.first()
+                        .toString() == "test/Main/sample/#java.lang.String#java.lang.String/PointingToDeclaration/"
                 } as MemberPageNode
                 val forJvm = (sampleFunction.documentable as DFunction).parameters.mapNotNull {
-                    val jvm = it.documentation.keys.first { it.platform == Platform.jvm }
+                    val jvm = it.documentation.keys.first { it.analysisPlatform == Platform.jvm }
                     it.documentation[jvm]
                 }
 
diff --git a/plugins/base/src/test/kotlin/model/InheritorsTest.kt b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
index 5daebb73..f5517abb 100644
--- a/plugins/base/src/test/kotlin/model/InheritorsTest.kt
+++ b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
@@ -31,7 +31,7 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
         ) {
             with((this / "inheritors" / "A").cast<DInterface>()) {
                 val map = extra[InheritorsInfo].assertNotNull("InheritorsInfo").value
-                with(map.keys.also { it counts 1 }.find { it.platform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }
+                with(map.keys.also { it counts 1 }.find { it.analysisPlatform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }
                 ) {
                     this counts 1
                     first().classNames equals "B"
@@ -77,11 +77,11 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
                 with((m / "inheritors" / "A").cast<DInterface>()) {
                     val map = extra[InheritorsInfo].assertNotNull("InheritorsInfo").value
                     with(map.keys.also { it counts 2 }) {
-                        with(find { it.platform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }) {
+                        with(find { it.analysisPlatform == Platform.jvm }.assertNotNull("jvm key").let { map[it]!! }) {
                             this counts 1
                             first().classNames equals "B"
                         }
-                        with(find { it.platform == Platform.js }.assertNotNull("js key").let { map[it]!! }) {
+                        with(find { it.analysisPlatform == Platform.js }.assertNotNull("js key").let { map[it]!! }) {
                             this counts 2
                             val classes = listOf("B", "C")
                             assertTrue(all { classes.contains(it.classNames) }, "One of subclasses missing in js" )
diff --git a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
index 452439e9..21a70802 100644
--- a/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
+++ b/plugins/base/src/test/kotlin/renderers/RenderingOnlyTestBase.kt
@@ -1,21 +1,17 @@
 package renderers
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.DokkaConfigurationImpl
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.RootCreator
 import org.jetbrains.dokka.base.resolvers.external.DokkaExternalLocationProviderFactory
 import org.jetbrains.dokka.base.resolvers.external.JavadocExternalLocationProviderFactory
 import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProviderFactory
-import org.jetbrains.dokka.base.resolvers.local.LocationProvider
-import org.jetbrains.dokka.base.resolvers.local.LocationProviderFactory
 import org.jetbrains.dokka.base.signatures.KotlinSignatureProvider
 import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
-import org.jetbrains.dokka.base.transformers.pages.samples.DefaultSamplesTransformer
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.Documentable
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.model.doc.DocTag
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
@@ -35,7 +31,6 @@ abstract class RenderingOnlyTestBase {
         DokkaBase().htmlPreprocessors to { _ -> RootCreator },
         DokkaBase().externalLocationProviderFactory to { ::JavadocExternalLocationProviderFactory },
         DokkaBase().externalLocationProviderFactory to { ::DokkaExternalLocationProviderFactory },
-        sourceSetCache = SourceSetCache(),
         testConfiguration = DokkaConfigurationImpl(
             "", "", null, false, emptyList(), emptyList(), emptyMap(), emptyList(), false
         )
@@ -110,7 +105,7 @@ internal object EmptyCommentConverter : CommentsToContentConverter {
     override fun buildContent(
         docTag: DocTag,
         dci: DCI,
-        sourceSets: Set<SourceSetData>,
+        sourceSets: Set<DokkaSourceSet>,
         styles: Set<Style>,
         extras: PropertyContainer<ContentNode>
     ): List<ContentNode> = emptyList()
diff --git a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
index b10202bb..6ceb805b 100644
--- a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
@@ -4,15 +4,33 @@ import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.SourceRootImpl
 import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.ContentDivergentGroup
 import org.junit.jupiter.api.Test
 import renderers.*
 
 class DivergentTest : RenderingOnlyTestBase() {
-    private val js = SourceSetData("root", "js", "JS", Platform.js, listOf(SourceRootImpl("pl1")))
-    private val jvm = SourceSetData("root", "jvm", "JVM", Platform.jvm, listOf(SourceRootImpl("pl1")))
-    private val native = SourceSetData("root", "native", "NATIVE", Platform.native, listOf(SourceRootImpl("pl1")))
+    private val js = defaultSourceSet.copy(
+        "root",
+        "JS",
+        "js",
+        analysisPlatform = Platform.js,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val jvm = defaultSourceSet.copy(
+        "root",
+        "JVM",
+        "jvm",
+
+        analysisPlatform = Platform.jvm,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val native = defaultSourceSet.copy(
+        "root",
+        "NATIVE",
+        "native",
+        analysisPlatform = Platform.native,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
 
     @Test
     fun simpleWrappingCase() {
@@ -178,10 +196,10 @@ class DivergentTest : RenderingOnlyTestBase() {
 
         HtmlRenderer(context).render(page)
         renderedContent.match(
-            Div(Div(Span(Div(Div("NATIVE")))), Div(Div(Div("a"))),"a+"),
-            Div(Div(Span(Div(Div("JS")))), Div(Div(Div("bd"))),"bd+"),
+            Div(Div(Span(Div(Div("NATIVE")))), Div(Div(Div("a"))), "a+"),
+            Div(Div(Span(Div(Div("JS")))), Div(Div(Div("bd"))), "bd+"),
             Div(Div(Span(Div(Div("JVM")))), Div(Div(Div("c")))),
-            Div(Div(Span(Div(Div("NATIVE")))), Div(Div(Div("e"))),"e+"),
+            Div(Div(Span(Div(Div("NATIVE")))), Div(Div(Div("e"))), "e+"),
         )
     }
 
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
index 878f442b..c868cfd5 100644
--- a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -3,7 +3,6 @@ package renderers.html
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.SourceRootImpl
 import org.jetbrains.dokka.base.renderers.html.HtmlRenderer
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.TextStyle
 import org.junit.jupiter.api.Test
 import renderers.Div
@@ -12,9 +11,28 @@ import renderers.TestPage
 import renderers.match
 
 class SourceSetDependentHintTest : RenderingOnlyTestBase() {
-    private val pl1 = SourceSetData("root", "pl1", "pl3",Platform.js, listOf(SourceRootImpl("pl1")))
-    private val pl2 = SourceSetData("root","pl2", "pl3", Platform.jvm, listOf(SourceRootImpl("pl1")))
-    private val pl3 = SourceSetData("root","pl3", "pl3", Platform.native, listOf(SourceRootImpl("pl1")))
+
+    private val pl1 = defaultSourceSet.copy(
+        "root",
+        "pl1",
+        "pl1",
+        analysisPlatform = Platform.js,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val pl2 = defaultSourceSet.copy(
+        "root",
+        "pl2",
+        "pl2",
+        analysisPlatform = Platform.jvm,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
+    private val pl3 = defaultSourceSet.copy(
+        "root",
+        "pl3",
+        "pl3",
+        analysisPlatform = Platform.native,
+        sourceRoots = listOf(SourceRootImpl("pl1"))
+    )
 
     @Test
     fun platformIndependentCase() {
diff --git a/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
new file mode 100644
index 00000000..771cabaa
--- /dev/null
+++ b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
@@ -0,0 +1,30 @@
+package renderers.html
+
+import org.jetbrains.dokka.DokkaSourceSetImpl
+import org.jetbrains.dokka.Platform
+
+internal val defaultSourceSet = DokkaSourceSetImpl(
+    moduleName = "DEFAULT",
+    displayName = "DEFAULT",
+    sourceSetID = "DEFAULT",
+    classpath = emptyList(),
+    sourceRoots = emptyList(),
+    dependentSourceSets = emptyList(),
+    samples = emptyList(),
+    includes = emptyList(),
+    includeNonPublic = false,
+    includeRootPackage = false,
+    reportUndocumented = false,
+    skipEmptyPackages = true,
+    skipDeprecated = false,
+    jdkVersion = 8,
+    sourceLinks = emptyList(),
+    perPackageOptions = emptyList(),
+    externalDocumentationLinks = emptyList(),
+    languageVersion = null,
+    apiVersion = null,
+    noStdlibLink = false,
+    noJdkLink = false,
+    suppressedFiles = emptyList(),
+    analysisPlatform = Platform.DEFAULT
+)
\ No newline at end of file
diff --git a/plugins/gfm/src/main/kotlin/GfmPlugin.kt b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
index fb83d3b0..53ee2b53 100644
--- a/plugins/gfm/src/main/kotlin/GfmPlugin.kt
+++ b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
@@ -1,20 +1,19 @@
 package org.jetbrains.dokka.gfm
 
 import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.DefaultRenderer
 import org.jetbrains.dokka.base.renderers.PackageListCreator
 import org.jetbrains.dokka.base.renderers.RootCreator
 import org.jetbrains.dokka.base.resolvers.local.DefaultLocationProvider
 import org.jetbrains.dokka.base.resolvers.local.LocationProviderFactory
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.plugability.plugin
 import org.jetbrains.dokka.plugability.query
 import org.jetbrains.dokka.transformers.pages.PageTransformer
-import java.lang.StringBuilder
 
 
 class GfmPlugin : DokkaPlugin() {
@@ -66,7 +65,7 @@ open class CommonmarkRenderer(
     override fun StringBuilder.buildList(
         node: ContentList,
         pageContext: ContentPage,
-        platformRestriction: Set<SourceSetData>?
+        platformRestriction: Set<DokkaSourceSet>?
     ) {
         buildParagraph()
         buildListLevel(node, pageContext)
@@ -114,17 +113,21 @@ open class CommonmarkRenderer(
     override fun StringBuilder.buildPlatformDependent(
         content: PlatformHintedContent,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<SourceSetData>?
+        sourceSetRestriction: Set<DokkaSourceSet>?
     ) {
         val distinct = content.sourceSets.map {
-            it to StringBuilder().apply {buildContentNode(content.inner, pageContext, setOf(it)) }.toString()
-        }.groupBy(Pair<SourceSetData, String>::second, Pair<SourceSetData, String>::first)
+            it to StringBuilder().apply { buildContentNode(content.inner, pageContext, setOf(it)) }.toString()
+        }.groupBy(Pair<DokkaSourceSet, String>::second, Pair<DokkaSourceSet, String>::first)
 
         if (distinct.size == 1)
             append(distinct.keys.single())
         else
             distinct.forEach { text, platforms ->
-                append(platforms.joinToString(prefix = " [", postfix = "] $text") { "${it.moduleName}/${it.sourceSetID}"  })
+                append(
+                    platforms.joinToString(
+                        prefix = " [",
+                        postfix = "] $text"
+                    ) { "${it.moduleName}/${it.sourceSetID}" })
             }
     }
 
@@ -135,7 +138,7 @@ open class CommonmarkRenderer(
     override fun StringBuilder.buildTable(
         node: ContentTable,
         pageContext: ContentPage,
-        platformRestriction: Set<SourceSetData>?
+        platformRestriction: Set<DokkaSourceSet>?
     ) {
 
         buildParagraph()
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt
index a92320dd..f8ecf868 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocLocationProvider.kt
@@ -1,11 +1,11 @@
 package javadoc
 
 import javadoc.pages.*
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.resolvers.local.LocationProvider
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.pages.ContentPage
 import org.jetbrains.dokka.pages.PageNode
 import org.jetbrains.dokka.pages.RootPageNode
@@ -22,8 +22,8 @@ class JavadocLocationProvider(pageRoot: RootPageNode, private val context: Dokka
         externalLocationProviderFactories.asSequence().map { it.getExternalLocationProvider("javadoc10") }
             .filterNotNull().take(1).firstOrNull()
     private val externalDocumentationLinks by lazy {
-        context.configuration.passesConfigurations
-            .filter { passConfig -> passConfig.analysisPlatform == Platform.jvm }
+        context.configuration.sourceSets
+            .filter { sourceSet -> sourceSet.analysisPlatform == Platform.jvm }
             .flatMap { it.externalDocumentationLinks }
             .distinct()
     }
@@ -65,7 +65,7 @@ class JavadocLocationProvider(pageRoot: RootPageNode, private val context: Dokka
 
     private operator fun IdentityHashMap<PageNode, List<String>>.get(dri: DRI) = this[nodeIndex[dri]]
 
-    override fun resolve(dri: DRI, sourceSets: List<SourceSetData>, context: PageNode?): String =
+    override fun resolve(dri: DRI, sourceSets: List<DokkaSourceSet>, context: PageNode?): String =
         context?.let { resolve(it, skipExtension = false) } ?: nodeIndex[dri]?.let {
             resolve(it, skipExtension = true)
         } ?: with(externalLocationProvider!!) {
@@ -79,19 +79,20 @@ class JavadocLocationProvider(pageRoot: RootPageNode, private val context: Dokka
             throw IllegalStateException("Path for ${node::class.java.canonicalName}:${node.name} not found")
         }
 
-    fun resolve(link: LinkJavadocListEntry, dir: String = "", skipExtension: Boolean = true) = pathIndex[link.dri.first()]?.let {
-        when (link.kind) {
-            JavadocContentKind.Class -> it
-            JavadocContentKind.OverviewSummary -> it.dropLast(1) + "index"
-            JavadocContentKind.PackageSummary -> it.dropLast(1) + "package-summary"
-            JavadocContentKind.AllClasses -> it.dropLast(1) + "allclasses"
-            JavadocContentKind.OverviewTree -> it.dropLast(1) + "overview-tree"
-            JavadocContentKind.PackageTree -> it.dropLast(1) + "package-tree"
-            else -> it
-        }
-    }?.joinToString("/")?.let {if (skipExtension) "$it.html" else it}?.let {
-        Paths.get(dir).relativize(Paths.get(it)).toString()
-    } ?: run {""} //TODO just a glue to compile it on HMPP
+    fun resolve(link: LinkJavadocListEntry, dir: String = "", skipExtension: Boolean = true) =
+        pathIndex[link.dri.first()]?.let {
+            when (link.kind) {
+                  JavadocContentKind.Class -> it
+                JavadocContentKind.OverviewSummary -> it.dropLast(1) + "index"
+                JavadocContentKind.PackageSummary -> it.dropLast(1) + "package-summary"
+                JavadocContentKind.AllClasses -> it.dropLast(1) + "allclasses"
+                JavadocContentKind.OverviewTree -> it.dropLast(1) + "overview-tree"
+                JavadocContentKind.PackageTree -> it.dropLast(1) + "package-tree"
+                else -> it
+            }
+        }?.joinToString("/")?.let { if (skipExtension) "$it.html" else it }?.let {
+            Paths.get(dir).relativize(Paths.get(it)).toString()
+        } ?: run { "" } //TODO just a glue to compile it on HMPP
 
     override fun resolveRoot(node: PageNode): String {
         TODO("Not yet implemented")
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt b/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt
index 53292225..6cf34ed1 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/JavadocPageCreator.kt
@@ -1,6 +1,7 @@
 package javadoc
 
 import javadoc.pages.*
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.base.signatures.SignatureProvider
 import org.jetbrains.dokka.base.signatures.function
@@ -40,7 +41,7 @@ open class JavadocPageCreator(
         )
 
     fun pageForClasslike(c: DClasslike): JavadocClasslikePageNode? =
-        c.sourceSets.firstOrNull { it.platform == Platform.jvm }?.let { jvm ->
+        c.sourceSets.firstOrNull { it.analysisPlatform == Platform.jvm }?.let { jvm ->
             JavadocClasslikePageNode(
                 name = c.name.orEmpty(),
                 content = contentForClasslike(c),
@@ -72,11 +73,11 @@ open class JavadocPageCreator(
         JavadocContentGroup(
             setOf(m.dri),
             JavadocContentKind.OverviewSummary,
-            m.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+            m.sourceSets.filter { it.analysisPlatform == Platform.jvm }.toSet()
         ) {
             title(m.name, "0.0.1", dri = setOf(m.dri), kind = ContentKind.Main)
             list("Packages", "Package", setOf(m.dri), ContentKind.Packages, m.packages.sortedBy { it.name }.map { p ->
-                val description = p.documentation.entries.find { (k, _) -> k.platform == Platform.jvm }?.value?.let {
+                val description = p.documentation.entries.find { (k, _) -> k.analysisPlatform == Platform.jvm }?.value?.let {
                     it.children.firstIsInstanceOrNull<Description>()?.let { description ->
                         DocTagToContentConverter.buildContent(
                             description.root,
@@ -96,7 +97,7 @@ open class JavadocPageCreator(
         JavadocContentGroup(
             setOf(p.dri),
             JavadocContentKind.PackageSummary,
-            p.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+            p.sourceSets.filter { it.analysisPlatform == Platform.jvm }.toSet()
         ) {
             title(p.name, "0.0.1", dri = setOf(p.dri), kind = ContentKind.Packages)
             list("Packages", "Package", setOf(p.dri), ContentKind.Packages, p.classlikes.sortedBy { it.name }.map { c ->
@@ -111,7 +112,7 @@ open class JavadocPageCreator(
         JavadocContentGroup(
             setOf(c.dri),
             JavadocContentKind.Class,
-            c.sourceSets.filter { it.platform == Platform.jvm }.toSet()
+            c.sourceSets.filter { it.analysisPlatform == Platform.jvm }.toSet()
         ) {
             title(
                 c.name.orEmpty(),
@@ -146,7 +147,7 @@ open class JavadocPageCreator(
             is UnresolvedBound -> p.name
         }
 
-    private fun DFunction.toJavadocFunction(sourceSetData: SourceSetData) = JavadocFunctionNode(
+    private fun DFunction.toJavadocFunction(sourceSetData: DokkaSourceSet) = JavadocFunctionNode(
         name = name,
         signature = signatureProvider.signature(this).jvmSignature(),
         brief = TextNode(description(sourceSetData), setOf(sourceSetData)),
@@ -161,12 +162,12 @@ open class JavadocPageCreator(
     )
 
     fun List<ContentNode>.jvmSignature(): ContentNode =
-        first { it.sourceSets.any { it.platform == Platform.jvm } }
+        first { it.sourceSets.any { it.analysisPlatform == Platform.jvm } }
 
-    private fun Documentable.description(sourceSetData: SourceSetData): String =
+    private fun Documentable.description(sourceSetData: DokkaSourceSet): String =
         findNodeInDocumentation<Description>(sourceSetData)
 
-    private inline fun <reified T : TagWrapper> Documentable.findNodeInDocumentation(sourceSetData: SourceSetData): String =
+    private inline fun <reified T : TagWrapper> Documentable.findNodeInDocumentation(sourceSetData: DokkaSourceSet): String =
         documentation[sourceSetData]?.children?.firstIsInstanceOrNull<T>()?.root?.children?.firstIsInstanceOrNull<Text>()?.body.orEmpty()
 }
 
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/KorteJavadocRenderer.kt b/plugins/javadoc/src/main/kotlin/javadoc/KorteJavadocRenderer.kt
index 370ee68b..23a7c9ed 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/KorteJavadocRenderer.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/KorteJavadocRenderer.kt
@@ -12,7 +12,7 @@ import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.links.sureClassNames
 import org.jetbrains.dokka.model.ImplementedInterfaces
 import org.jetbrains.dokka.model.InheritedFunction
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.renderers.Renderer
@@ -269,13 +269,13 @@ class KorteJavadocRenderer(val outputWriter: OutputWriter, val context: DokkaCon
             ) + renderJavadocContentNode(node.content)
 
         private fun renderImplementedInterfaces(node: JavadocClasslikePageNode) =
-            node.extras[ImplementedInterfaces]?.interfaces?.entries?.firstOrNull { it.key.platform == Platform.jvm }?.value?.map { it.displayable() } // TODO: REMOVE HARDCODED JVM DEPENDENCY
+            node.extras[ImplementedInterfaces]?.interfaces?.entries?.firstOrNull { it.key.analysisPlatform == Platform.jvm }?.value?.map { it.displayable() } // TODO: REMOVE HARDCODED JVM DEPENDENCY
             .orEmpty()
 
         private fun renderClasslikeMethods(nodes: List<JavadocFunctionNode>): TemplateMap {
             val (inherited, own) = nodes.partition {
                 val extra = it.extras[InheritedFunction]
-                extra?.inheritedFrom?.keys?.first { it.platform == Platform.jvm }?.let { jvm ->
+                extra?.inheritedFrom?.keys?.first { it.analysisPlatform == Platform.jvm }?.let { jvm ->
                     extra.isInherited(jvm)
                 } ?: false
             }
@@ -294,7 +294,7 @@ class KorteJavadocRenderer(val outputWriter: OutputWriter, val context: DokkaCon
         private fun renderInheritedMethod(node: JavadocFunctionNode): TemplateMap {
             val inheritedFrom = node.extras[InheritedFunction]?.inheritedFrom
             return mapOf(
-                "inheritedFrom" to inheritedFrom?.entries?.firstOrNull { it.key.platform == Platform.jvm }?.value?.displayable() // TODO: REMOVE HARDCODED JVM DEPENDENCY
+                "inheritedFrom" to inheritedFrom?.entries?.firstOrNull { it.key.analysisPlatform == Platform.jvm }?.value?.displayable() // TODO: REMOVE HARDCODED JVM DEPENDENCY
                 .orEmpty(),
                 "name" to node.name
             )
@@ -370,7 +370,7 @@ class KorteJavadocRenderer(val outputWriter: OutputWriter, val context: DokkaCon
             )
         }
 
-        private fun resolveLink(address: DRI, sourceSets: Set<SourceSetData>) =
+        private fun resolveLink(address: DRI, sourceSets: Set<DokkaSourceSet>) =
             locationProvider.resolve(address, sourceSets.toList()).let {
                 val afterFormattingToHtml = formatToEndWithHtml(it)
                 if (currentLocation != null) afterFormattingToHtml.relativizePath(currentLocation)
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocContentNodes.kt b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocContentNodes.kt
index 6587e290..286223fa 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocContentNodes.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocContentNodes.kt
@@ -1,7 +1,7 @@
 package javadoc.pages
 
 import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.pages.*
 
@@ -12,7 +12,7 @@ enum class JavadocContentKind : Kind {
 abstract class JavadocContentNode(
     dri: Set<DRI>,
     kind: Kind,
-    override val sourceSets: Set<SourceSetData>
+    override val sourceSets: Set<DokkaSourceSet>
 ) : ContentNode {
     override val dci: DCI = DCI(dri, kind)
     override val style: Set<Style> = emptySet()
@@ -27,7 +27,7 @@ interface JavadocListEntry {
 class EmptyNode(
     dri: DRI,
     kind: Kind,
-    override val sourceSets: Set<SourceSetData>,
+    override val sourceSets: Set<DokkaSourceSet>,
     override val extra: PropertyContainer<ContentNode> = PropertyContainer.empty()
 ) : ContentNode {
     override val dci: DCI = DCI(setOf(dri), kind)
@@ -42,7 +42,7 @@ class EmptyNode(
 class JavadocContentGroup(
     val dri: Set<DRI>,
     val kind: Kind,
-    sourceSets: Set<SourceSetData>,
+    sourceSets: Set<DokkaSourceSet>,
     val children: List<JavadocContentNode>
 ) : JavadocContentNode(dri, kind, sourceSets) {
 
@@ -50,7 +50,7 @@ class JavadocContentGroup(
         operator fun invoke(
             dri: Set<DRI>,
             kind: Kind,
-            sourceSets: Set<SourceSetData>,
+            sourceSets: Set<DokkaSourceSet>,
             block: JavaContentGroupBuilder.() -> Unit
         ): JavadocContentGroup =
             JavadocContentGroup(dri, kind, sourceSets, JavaContentGroupBuilder(sourceSets).apply(block).list)
@@ -59,7 +59,7 @@ class JavadocContentGroup(
     override fun hasAnyContent(): Boolean = children.isNotEmpty()
 }
 
-class JavaContentGroupBuilder(val sourceSets: Set<SourceSetData>) {
+class JavaContentGroupBuilder(val sourceSets: Set<DokkaSourceSet>) {
     val list = mutableListOf<JavadocContentNode>()
 }
 
@@ -69,7 +69,7 @@ class TitleNode(
     val parent: String?,
     val dri: Set<DRI>,
     val kind: Kind,
-    sourceSets: Set<SourceSetData>
+    sourceSets: Set<DokkaSourceSet>
 ) : JavadocContentNode(dri, kind, sourceSets) {
     override fun hasAnyContent(): Boolean = !title.isBlank() || !version.isBlank()
 }
@@ -86,7 +86,7 @@ fun JavaContentGroupBuilder.title(
 
 data class TextNode(
     val text: String,
-    override val sourceSets: Set<SourceSetData>
+    override val sourceSets: Set<DokkaSourceSet>
 ) : JavadocContentNode(emptySet(), ContentKind.Main, sourceSets) {
     override fun hasAnyContent(): Boolean = !text.isBlank()
 }
@@ -97,7 +97,7 @@ class ListNode(
     val children: List<JavadocListEntry>,
     val dri: Set<DRI>,
     val kind: Kind,
-    sourceSets: Set<SourceSetData>
+    sourceSets: Set<DokkaSourceSet>
 ) : JavadocContentNode(dri, kind, sourceSets) {
     override fun hasAnyContent(): Boolean = children.isNotEmpty()
 }
@@ -117,7 +117,7 @@ class LinkJavadocListEntry(
     val name: String,
     val dri: Set<DRI>,
     val kind: Kind = ContentKind.Symbol,
-    val sourceSets: Set<SourceSetData>
+    val sourceSets: Set<DokkaSourceSet>
 ) :
     JavadocListEntry {
     override val stringTag: String
@@ -127,7 +127,7 @@ class LinkJavadocListEntry(
 
     private var builtString: String? = null
 
-    fun build(body: (String, Set<DRI>, Kind, List<SourceSetData>) -> String) {
+    fun build(body: (String, Set<DRI>, Kind, List<DokkaSourceSet>) -> String) {
         builtString = body(name, dri, kind, sourceSets.toList())
     }
 }
diff --git a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
index becacd26..8cd16dba 100644
--- a/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
+++ b/plugins/javadoc/src/main/kotlin/javadoc/pages/JavadocPageNodes.kt
@@ -418,7 +418,7 @@ class TreeViewPage(
         (this as? WithExpectActual).descriptorForPlatform(platform)
 
     private fun WithExpectActual?.descriptorForPlatform(platform: Platform = Platform.jvm) = this?.let {
-        it.sources.entries.find { it.key.platform == platform }?.value?.let { it as? DescriptorDocumentableSource }?.descriptor as? ClassDescriptor
+        it.sources.entries.find { it.key.analysisPlatform == platform }?.value?.let { it as? DescriptorDocumentableSource }?.descriptor as? ClassDescriptor
     }
 
     data class InheritanceNode(
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index 80971ae2..37c13442 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -3,7 +3,7 @@ package org.jetbrains.dokka
 import com.google.gson.Gson
 import kotlinx.cli.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
-import org.jetbrains.dokka.DokkaConfiguration.PassConfiguration.*
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet.*
 import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import org.jetbrains.dokka.utilities.cast
 import java.io.*
@@ -31,9 +31,9 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
         description = "Path to cache folder, or 'default' to use ~/.cache/dokka, if not provided caching is disabled"
     )
 
-    override val passesConfigurations by parser.option(
+    override val sourceSets by parser.option(
         ArgTypeArgument,
-        description = "Single dokka pass",
+        description = "Single dokka source set",
         fullName = "pass"
     ).multiple()
 
@@ -83,18 +83,18 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
     init {
         parser.parse(args)
 
-        passesConfigurations.all {
+        sourceSets.all {
             it.perPackageOptions.cast<MutableList<DokkaConfiguration.PackageOptions>>()
                 .addAll(parsePerPackageOptions(globalPackageOptions))
         }
 
-        passesConfigurations.all {
+        sourceSets.all {
             it.externalDocumentationLinks.cast<MutableList<ExternalDocumentationLink>>().addAll(parseLinks(globalLinks))
         }
 
         globalSrcLink.forEach {
             if (it.isNotEmpty() && it.contains("="))
-                passesConfigurations.all { pass ->
+                sourceSets.all { pass ->
                     pass.sourceLinks.cast<MutableList<SourceLinkDefinitionImpl>>()
                         .add(SourceLinkDefinitionImpl.parseSourceLinkDefinition(it))
                 }
@@ -103,13 +103,13 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
             }
         }
 
-        passesConfigurations.forEach {
+        sourceSets.forEach {
             it.externalDocumentationLinks.cast<MutableList<ExternalDocumentationLink>>().addAll(defaultLinks(it))
         }
     }
 }
 
-fun passArguments(args: Array<String>): DokkaConfiguration.PassConfiguration {
+fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
 
     val parser = ArgParser("passConfiguration", prefixStyle = ArgParser.OptionPrefixStyle.JVM)
 
@@ -226,7 +226,7 @@ fun passArguments(args: Array<String>): DokkaConfiguration.PassConfiguration {
 
     parser.parse(args)
 
-    return object : DokkaConfiguration.PassConfiguration {
+    return object : DokkaConfiguration.DokkaSourceSet {
         override val moduleName = moduleName
         override val displayName = displayName
         override val sourceSetID = sourceSetID
@@ -289,8 +289,8 @@ object ArgTypeSourceLinkDefinition : ArgType<DokkaConfiguration.SourceLinkDefini
         get() = "{ String that represent source links }"
 }
 
-object ArgTypeArgument : ArgType<DokkaConfiguration.PassConfiguration>(true) {
-    override fun convert(value: kotlin.String, name: kotlin.String): DokkaConfiguration.PassConfiguration =
+object ArgTypeArgument : ArgType<DokkaConfiguration.DokkaSourceSet>(true) {
+    override fun convert(value: kotlin.String, name: kotlin.String): DokkaConfiguration.DokkaSourceSet =
         passArguments(value.split(" ").filter { it.isNotBlank() }.toTypedArray())
 
     override val description: kotlin.String
@@ -305,7 +305,7 @@ object ArgTypeHelpPass : ArgType<Any>(false) {
         get() = ""
 }
 
-fun defaultLinks(config: DokkaConfiguration.PassConfiguration): MutableList<ExternalDocumentationLink> =
+fun defaultLinks(config: DokkaConfiguration.DokkaSourceSet): MutableList<ExternalDocumentationLink> =
     mutableListOf<ExternalDocumentationLink>().apply {
         if (!config.noJdkLink)
             this += DokkaConfiguration.ExternalDocumentationLink
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
index cef3695a..8483cd60 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
@@ -38,7 +38,7 @@ open class DokkaCollectorTask : DefaultTask() {
         configuration = passesConfigurations.fold(initial) { acc, it: GradleDokkaConfigurationImpl ->
             if(acc.format != it.format || acc.cacheRoot != it.cacheRoot)
                 throw IllegalStateException("Dokka task configurations differ on core arguments (format, cacheRoot)")
-            acc.passesConfigurations = acc.passesConfigurations + it.passesConfigurations
+            acc.sourceSets = acc.sourceSets + it.sourceSets
             acc.pluginsClasspath = (acc.pluginsClasspath + it.pluginsClasspath).distinct()
             acc
         }
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 1759b6f3..cc9471a1 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
@@ -69,9 +69,9 @@ open class DokkaTask : DefaultTask(), Configurable {
 
     internal var config: GradleDokkaConfigurationImpl? = null
 
-    var dokkaSourceSets: NamedDomainObjectContainer<GradlePassConfigurationImpl>
+    var dokkaSourceSets: NamedDomainObjectContainer<GradleDokkaSourceSet>
         @Suppress("UNCHECKED_CAST")
-        @Nested get() = (DslObject(this).extensions.getByName(SOURCE_SETS_EXTENSION_NAME) as NamedDomainObjectContainer<GradlePassConfigurationImpl>)
+        @Nested get() = (DslObject(this).extensions.getByName(SOURCE_SETS_EXTENSION_NAME) as NamedDomainObjectContainer<GradleDokkaSourceSet>)
         internal set(value) = DslObject(this).extensions.add(SOURCE_SETS_EXTENSION_NAME, value)
 
     private val kotlinTasks: List<Task> by lazy {
@@ -184,7 +184,7 @@ open class DokkaTask : DefaultTask(), Configurable {
             .map { defaultPassConfiguration(it, globalConfig) }.takeIf { it.isNotEmpty() }
             ?: listOf(
                 defaultPassConfiguration(
-                    collectSinglePassConfiguration(GradlePassConfigurationImpl("main")),
+                    collectSinglePassConfiguration(GradleDokkaSourceSet("main")),
                     null
                 )
             ).takeIf { project.isNotMultiplatformProject() } ?: emptyList()
@@ -199,7 +199,7 @@ open class DokkaTask : DefaultTask(), Configurable {
             format = outputFormat
             cacheRoot = this@DokkaTask.cacheRoot
             offlineMode = this@DokkaTask.offlineMode
-            passesConfigurations = defaultModulesConfiguration
+            sourceSets = passConfigurations
             pluginsClasspath = pluginsClasspathConfiguration.resolve().toList()
             pluginsConfiguration = this@DokkaTask.pluginsConfiguration
             failOnWarning = this@DokkaTask.failOnWarning
@@ -207,12 +207,12 @@ open class DokkaTask : DefaultTask(), Configurable {
     }
 
 
-    protected val passConfigurations: List<GradlePassConfigurationImpl>
+    protected val passConfigurations: List<GradleDokkaSourceSet>
         get() = dokkaSourceSets
             .filterNot { it.name.toLowerCase() == GLOBAL_CONFIGURATION_NAME }
             .map { collectSinglePassConfiguration(it) }
 
-    protected fun collectSinglePassConfiguration(config: GradlePassConfigurationImpl): GradlePassConfigurationImpl {
+    protected fun collectSinglePassConfiguration(config: GradleDokkaSourceSet): GradleDokkaSourceSet {
         val userConfig = config
             .apply {
                 collectKotlinTasks?.let {
@@ -259,7 +259,7 @@ open class DokkaTask : DefaultTask(), Configurable {
         }
     }
 
-    protected fun collectFromSinglePlatformOldPlugin(name: String, userConfig: GradlePassConfigurationImpl) =
+    protected fun collectFromSinglePlatformOldPlugin(name: String, userConfig: GradleDokkaSourceSet) =
         kotlinTasks.find { it.name == name }
             ?.let { configExtractor.extractFromKotlinTasks(listOf(it)) }
             ?.singleOrNull()
@@ -269,7 +269,7 @@ open class DokkaTask : DefaultTask(), Configurable {
             ?: userConfig
 
     protected fun mergeUserConfigurationAndPlatformData(
-        userConfig: GradlePassConfigurationImpl,
+        userConfig: GradleDokkaSourceSet,
         autoConfig: PlatformData
     ) =
         userConfig.copy().apply {
@@ -281,9 +281,9 @@ open class DokkaTask : DefaultTask(), Configurable {
         }
 
     protected fun defaultPassConfiguration(
-        config: GradlePassConfigurationImpl,
-        globalConfig: GradlePassConfigurationImpl?
-    ): GradlePassConfigurationImpl {
+        config: GradleDokkaSourceSet,
+        globalConfig: GradleDokkaSourceSet?
+    ): GradleDokkaSourceSet {
         if (config.moduleName.isBlank()) {
             config.moduleName = project.name
         }
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
index f4e7730e..c5169ef8 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
@@ -16,7 +16,7 @@ import java.util.concurrent.Callable
 import kotlin.reflect.KMutableProperty
 import kotlin.reflect.full.memberProperties
 
-class GradleSourceRootImpl: SourceRoot, Serializable {
+class GradleSourceRootImpl : SourceRoot, Serializable {
     override var path: String = ""
         set(value) {
             field = File(value).absolutePath
@@ -25,33 +25,63 @@ class GradleSourceRootImpl: SourceRoot, Serializable {
     override fun toString(): String = path
 }
 
-open class GradlePassConfigurationImpl(@Transient val name: String = ""): PassConfiguration {
-    @Input @Optional override var classpath: List<String> = emptyList()
-    @Input override var moduleName: String = ""
-    @Input override var displayName: String = ""
-    @Input override var sourceSetID: String = ""
-    @Input override var sourceRoots: MutableList<SourceRoot> = mutableListOf()
-    @Input override var dependentSourceSets: MutableList<String> = mutableListOf()
-    @Input override var samples: List<String> = emptyList()
-    @Input override var includes: List<String> = emptyList()
-    @Input override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
-    @Input override var includeRootPackage: Boolean = DokkaDefaults.includeRootPackage
-    @Input override var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
-    @Input override var skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages
-    @Input override var skipDeprecated: Boolean = DokkaDefaults.skipDeprecated
-    @Input override var jdkVersion: Int = DokkaDefaults.jdkVersion
-    @Input override var sourceLinks: MutableList<SourceLinkDefinition> = mutableListOf()
-    @Input override var perPackageOptions: MutableList<PackageOptions> = mutableListOf()
-    @Input override var externalDocumentationLinks: MutableList<ExternalDocumentationLink> = mutableListOf()
-    @Input @Optional override var languageVersion: String? = null
-    @Input @Optional override var apiVersion: String? = null
-    @Input override var noStdlibLink: Boolean = DokkaDefaults.noStdlibLink
-    @Input override var noJdkLink: Boolean = DokkaDefaults.noJdkLink
-    @Input var noAndroidSdkLink: Boolean = false
-    @Input override var suppressedFiles: List<String> = emptyList()
-    @Input override var analysisPlatform: Platform = DokkaDefaults.analysisPlatform
-    @Input @Optional var platform: String? = null
-    @Transient var collectKotlinTasks: (() -> List<Any?>?)? = null
+open class GradleDokkaSourceSet(@Transient val name: String = "") : DokkaSourceSet {
+    @Input
+    @Optional
+    override var classpath: List<String> = emptyList()
+    @Input
+    override var moduleName: String = ""
+    @Input
+    override var displayName: String = ""
+    @Input
+    override var sourceSetID: String = ""
+    @Input
+    override var sourceRoots: MutableList<SourceRoot> = mutableListOf()
+    @Input
+    override var dependentSourceSets: MutableList<String> = mutableListOf()
+    @Input
+    override var samples: List<String> = emptyList()
+    @Input
+    override var includes: List<String> = emptyList()
+    @Input
+    override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
+    @Input
+    override var includeRootPackage: Boolean = DokkaDefaults.includeRootPackage
+    @Input
+    override var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
+    @Input
+    override var skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages
+    @Input
+    override var skipDeprecated: Boolean = DokkaDefaults.skipDeprecated
+    @Input
+    override var jdkVersion: Int = DokkaDefaults.jdkVersion
+    @Input
+    override var sourceLinks: MutableList<SourceLinkDefinition> = mutableListOf()
+    @Input
+    override var perPackageOptions: MutableList<PackageOptions> = mutableListOf()
+    @Input
+    override var externalDocumentationLinks: MutableList<ExternalDocumentationLink> = mutableListOf()
+    @Input
+    @Optional
+    override var languageVersion: String? = null
+    @Input
+    @Optional
+    override var apiVersion: String? = null
+    @Input
+    override var noStdlibLink: Boolean = DokkaDefaults.noStdlibLink
+    @Input
+    override var noJdkLink: Boolean = DokkaDefaults.noJdkLink
+    @Input
+    var noAndroidSdkLink: Boolean = false
+    @Input
+    override var suppressedFiles: List<String> = emptyList()
+    @Input
+    override var analysisPlatform: Platform = DokkaDefaults.analysisPlatform
+    @Input
+    @Optional
+    var platform: String? = null
+    @Transient
+    var collectKotlinTasks: (() -> List<Any?>?)? = null
 
     fun kotlinTasks(taskSupplier: Callable<List<Any>>) {
         collectKotlinTasks = { taskSupplier.call() }
@@ -117,25 +147,25 @@ class GradleExternalDocumentationLinkImpl : ExternalDocumentationLink, Serializa
     override var packageListUrl: URL = URL("http://")
 }
 
-class GradleDokkaModuleDescription: DokkaModuleDescription {
+class GradleDokkaModuleDescription : DokkaModuleDescription {
     override var name: String = ""
     override var path: String = ""
     override var docFile: String = ""
 }
 
-class GradleDokkaConfigurationImpl: DokkaConfiguration {
+class GradleDokkaConfigurationImpl : DokkaConfiguration {
     override var outputDir: String = ""
     override var format: String = DokkaDefaults.format
     override var cacheRoot: String? = DokkaDefaults.cacheRoot
     override var offlineMode: Boolean = DokkaDefaults.offlineMode
     override var failOnWarning: Boolean = DokkaDefaults.failOnWarning
-    override var passesConfigurations: List<GradlePassConfigurationImpl> = emptyList()
+    override var sourceSets: List<GradleDokkaSourceSet> = emptyList()
     override var pluginsClasspath: List<File> = emptyList()
     override var pluginsConfiguration: Map<String, String> = mutableMapOf()
     override var modules: List<GradleDokkaModuleDescription> = emptyList()
 }
 
-class GradlePackageOptionsImpl: PackageOptions, Serializable {
+class GradlePackageOptionsImpl : PackageOptions, Serializable {
     override var prefix: String = ""
     override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
     override var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
@@ -143,8 +173,8 @@ class GradlePackageOptionsImpl: PackageOptions, Serializable {
     override var suppress: Boolean = DokkaDefaults.suppress
 }
 
-internal fun GradlePassConfigurationImpl.copy(): GradlePassConfigurationImpl {
-    val newObj = GradlePassConfigurationImpl(this.name)
+internal fun GradleDokkaSourceSet.copy(): GradleDokkaSourceSet {
+    val newObj = GradleDokkaSourceSet(this.name)
     this::class.memberProperties.forEach { field ->
         if (field is KMutableProperty<*>) {
             val value = field.getter.call(this)
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 41d6e67a..2b076fd0 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
@@ -57,7 +57,7 @@ open class DokkaPlugin : Plugin<Project> {
             project.tasks.create(DOKKA_TASK_NAME, taskClass)
         }
         project.tasks.withType(taskClass) { task ->
-            task.dokkaSourceSets = project.container(GradlePassConfigurationImpl::class.java)
+            task.dokkaSourceSets = project.container(GradleDokkaSourceSet::class.java)
             task.dokkaRuntime = runtimeConfiguration
             task.pluginsClasspathConfiguration = pluginsConfiguration
             task.outputDirectory = File(project.buildDir, DOKKA_TASK_NAME).absolutePath
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 1ef04772..b0baabee 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -29,7 +29,6 @@ import org.eclipse.aether.transport.file.FileTransporterFactory
 import org.eclipse.aether.transport.http.HttpTransporterFactory
 import org.eclipse.aether.util.graph.visitor.PreorderNodeListGenerator
 import org.jetbrains.dokka.*
-import org.jetbrains.dokka.DokkaConfiguration.PackageOptions
 import java.io.File
 import java.net.URL
 
@@ -187,7 +186,7 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
                 throw MojoExecutionException("Incorrect path property, only Unix based path allowed.")
             }
         }
-        fun defaultLinks(config: PassConfigurationImpl): List<ExternalDocumentationLinkImpl> {
+        fun defaultLinks(config: DokkaSourceSetImpl): List<ExternalDocumentationLinkImpl> {
             val links = mutableListOf<ExternalDocumentationLinkImpl>()
             if (!config.noJdkLink)
                 links += DokkaConfiguration.ExternalDocumentationLink
@@ -201,7 +200,7 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             return links
         }
 
-        val passConfiguration = PassConfigurationImpl(
+        val sourceSet = DokkaSourceSetImpl(
             moduleName = moduleName,
             displayName = displayName,
             sourceSetID = sourceSetName,
@@ -246,8 +245,8 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             format = getOutFormat(),
             offlineMode = offlineMode,
             cacheRoot = cacheRoot,
-            passesConfigurations = listOf(passConfiguration).also {
-                if (passConfiguration.moduleName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
+            sourceSets = listOf(sourceSet).also {
+                if (sourceSet.moduleName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
             },
             pluginsClasspath = getArtifactByAether("org.jetbrains.dokka", "dokka-base", dokkaVersion) +
                     dokkaPlugins.map { getArtifactByAether(it.groupId, it.artifactId, it.version) }.flatten(),
diff --git a/testApi/src/main/kotlin/testApi/context/MockContext.kt b/testApi/src/main/kotlin/testApi/context/MockContext.kt
index e3da5f68..07aedf28 100644
--- a/testApi/src/main/kotlin/testApi/context/MockContext.kt
+++ b/testApi/src/main/kotlin/testApi/context/MockContext.kt
@@ -1,8 +1,7 @@
 package org.jetbrains.dokka.testApi.context
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.plugability.ExtensionPoint
@@ -15,8 +14,7 @@ import kotlin.reflect.full.memberProperties
 class MockContext(
     vararg extensions: Pair<ExtensionPoint<*>, (DokkaContext) -> Any>,
     private val testConfiguration: DokkaConfiguration? = null,
-    private val unusedExtensionPoints: List<ExtensionPoint<*>>? = null,
-    override val sourceSetCache: SourceSetCache
+    private val unusedExtensionPoints: List<ExtensionPoint<*>>? = null
 ) : DokkaContext {
     private val extensionMap by lazy {
         extensions.groupBy(Pair<ExtensionPoint<*>, (DokkaContext) -> Any>::first) {
diff --git a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
index 7248a4cb..ec2be689 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
@@ -1,9 +1,8 @@
 package org.jetbrains.dokka.testApi.testRunner
 
 import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.DokkaGenerator
-import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
 
@@ -16,13 +15,12 @@ internal class DokkaTestGenerator(
 
     fun generate() = with(testMethods) {
         val dokkaGenerator = DokkaGenerator(configuration, logger)
-        val sourceSetsCache = SourceSetCache()
 
         val context =
-            dokkaGenerator.initializePlugins(configuration, logger, sourceSetsCache, pluginOverrides)
+            dokkaGenerator.initializePlugins(configuration, logger, pluginOverrides)
         pluginsSetupStage(context)
 
-        val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(context, sourceSetsCache)
+        val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(context)
         documentablesCreationStage(modulesFromPlatforms)
 
         val filteredModules = dokkaGenerator.transformDocumentationModelBeforeMerge(modulesFromPlatforms, context)
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index 88595f85..624ea914 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -3,13 +3,11 @@ package org.jetbrains.dokka.testApi.testRunner
 import com.intellij.openapi.application.PathManager
 import org.jetbrains.dokka.*
 import org.jetbrains.dokka.model.DModule
-import org.jetbrains.dokka.model.SourceSetData
-import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jetbrains.dokka.utilities.DokkaLogger
 import org.junit.rules.TemporaryFolder
 import testApi.logger.TestLogger
 import java.io.File
@@ -66,7 +64,7 @@ abstract class AbstractCoreTest {
         val newConfiguration =
             configuration.copy(
                 outputDir = testDirPath.toAbsolutePath().toString(),
-                passesConfigurations = configuration.passesConfigurations.map {
+                sourceSets = configuration.sourceSets.map {
                     it.copy(sourceRoots = it.sourceRoots.map { it.copy(path = "${testDirPath.toAbsolutePath()}/${it.path}") })
                 }
             )
@@ -143,13 +141,13 @@ abstract class AbstractCoreTest {
         var pluginsClasspath: List<File> = emptyList()
         var pluginsConfigurations: Map<String, String> = emptyMap()
         var failOnWarning: Boolean = false
-        private val passesConfigurations = mutableListOf<PassConfigurationImpl>()
+        private val sourceSets = mutableListOf<DokkaSourceSetImpl>()
         fun build() = DokkaConfigurationImpl(
             outputDir = outputDir,
             format = format,
             cacheRoot = cacheRoot,
             offlineMode = offlineMode,
-            passesConfigurations = passesConfigurations,
+            sourceSets = sourceSets,
             pluginsClasspath = pluginsClasspath,
             pluginsConfiguration = pluginsConfigurations,
             modules = emptyList(),
@@ -157,18 +155,18 @@ abstract class AbstractCoreTest {
         )
 
         fun passes(block: Passes.() -> Unit) {
-            passesConfigurations.addAll(Passes().apply(block))
+            sourceSets.addAll(Passes().apply(block))
         }
     }
 
     @DokkaConfigurationDsl
-    protected class Passes : ArrayList<PassConfigurationImpl>() {
-        fun pass(block: DokkaPassConfigurationBuilder.() -> Unit) =
-            add(DokkaPassConfigurationBuilder().apply(block).build())
+    protected class Passes : ArrayList<DokkaSourceSetImpl>() {
+        fun pass(block: DokkaSourceSetBuilder.() -> Unit) =
+            add(DokkaSourceSetBuilder().apply(block).build())
     }
 
     @DokkaConfigurationDsl
-    protected class DokkaPassConfigurationBuilder(
+    protected class DokkaSourceSetBuilder(
         var moduleName: String = "root",
         var sourceSetID: String = "main",
         var displayName: String = "JVM",
@@ -193,7 +191,7 @@ abstract class AbstractCoreTest {
         var externalDocumentationLinks: List<ExternalDocumentationLinkImpl> = emptyList(),
         var sourceLinks: List<SourceLinkDefinitionImpl> = emptyList()
     ) {
-        fun build() = PassConfigurationImpl(
+        fun build() = DokkaSourceSetImpl(
             moduleName = moduleName,
             displayName = displayName,
             sourceSetID = sourceSetID,
-- 
cgit 


From b0e8622f374f6499058b0f083367b4a54512b702 Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Tue, 30 Jun 2020 23:06:03 +0200
Subject: Enforce workspace unique SourceSetID

---
 build.gradle.kts                                   |   4 +-
 core/src/main/kotlin/DokkaBootstrapImpl.kt         |   5 +-
 core/src/main/kotlin/DokkaGenerator.kt             |   2 +-
 .../main/kotlin/DokkaMultimoduleBootstrapImpl.kt   |   5 +-
 core/src/main/kotlin/configuration.kt              |  27 ++-
 core/src/main/kotlin/defaultConfiguration.kt       |  22 ++-
 core/src/main/kotlin/plugability/DokkaPlugin.kt    |   2 +-
 .../org/jetbrains/dokka/analysis/KotlinAnalysis.kt |   5 +-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |  22 +--
 .../main/kotlin/signatures/JvmSignatureUtils.kt    |   3 +-
 .../DocumentableVisibilityFilterTransformer.kt     |  12 +-
 .../EmptyPackagesFilterTransformer.kt              |   6 +-
 .../ModuleAndPackageDocumentationTransformer.kt    |   4 +-
 .../pages/samples/SamplesTransformer.kt            |   4 +-
 .../DefaultDescriptorToDocumentableTranslator.kt   |   4 +-
 .../psi/DefaultPsiToDocumentableTranslator.kt      |   2 +-
 plugins/base/src/test/kotlin/basic/DRITest.kt      |  40 ++--
 .../base/src/test/kotlin/basic/DokkaBasicTests.kt  |   6 +-
 .../src/test/kotlin/basic/FailOnWarningTest.kt     |  18 +-
 .../annotations/ContentForAnnotationsTest.kt       |   6 +-
 .../annotations/DepredatedAndSinceKotlinTest.kt    |   8 +-
 .../kotlin/content/params/ContentForParamsTest.kt  |   4 +-
 .../content/seealso/ContentForSeeAlsoTest.kt       |   6 +-
 .../content/signatures/ContentForSignaturesTest.kt |   4 +-
 .../SkippingParenthesisForConstructorsTest.kt      |   6 +-
 plugins/base/src/test/kotlin/enums/EnumsTest.kt    |  20 +-
 .../src/test/kotlin/expect/AbstractExpectTest.kt   |   6 +-
 .../test/kotlin/filter/DeprecationFilterTest.kt    |  22 +--
 .../test/kotlin/filter/EmptyPackagesFilterTest.kt  |  11 +-
 .../src/test/kotlin/filter/VisibilityFilterTest.kt |  22 +--
 plugins/base/src/test/kotlin/issues/IssuesTest.kt  |   6 +-
 .../kotlin/linkableContent/LinkableContentTest.kt  |  38 ++--
 .../DefaultLocationProviderTest.kt                 |   6 +-
 plugins/base/src/test/kotlin/markdown/KDocTest.kt  |   6 +-
 plugins/base/src/test/kotlin/markdown/LinkTest.kt  |  10 +-
 .../base/src/test/kotlin/model/InheritorsTest.kt   |   8 +-
 plugins/base/src/test/kotlin/model/PropertyTest.kt |   6 +-
 .../kotlin/multiplatform/BasicMultiplatformTest.kt |  10 +-
 .../test/kotlin/pageMerger/PageNodeMergerTest.kt   |  10 +-
 .../test/kotlin/renderers/html/DivergentTest.kt    |   8 +-
 .../renderers/html/SourceSetDependentHintTest.kt   |   8 +-
 .../test/kotlin/renderers/html/defaultSourceSet.kt |   9 +-
 .../test/kotlin/resourceLinks/ResourceLinksTest.kt |   6 +-
 .../PageTransformerBuilderTest.kt                  |  12 +-
 .../ReportUndocumentedTransformerTest.kt           | 136 ++++++-------
 .../DefaultPsiToDocumentableTranslatorTest.kt      |  14 +-
 plugins/base/src/test/kotlin/utils/ModelUtils.kt   |   4 +-
 plugins/gfm/src/main/kotlin/GfmPlugin.kt           |   6 +-
 .../javadoc/AbstractJavadocTemplateMapTest.kt      |   5 +-
 .../javadoc/src/test/kotlin/javadoc/JavadocTest.kt |   4 +-
 .../kotlin/javadoc/location/JavadocLocationTest.kt |   6 +-
 .../src/test/kotlin/KotlinAsJavaPluginTest.kt      |  13 +-
 runners/ant/build.gradle                           |  18 --
 runners/ant/src/main/kotlin/ant/dokka.kt           | 210 ---------------------
 runners/ant/src/main/resources/dokka-antlib.xml    |   3 -
 runners/cli/build.gradle.kts                       |   3 +-
 runners/cli/src/main/kotlin/cli/main.kt            |  57 +++---
 runners/gradle-plugin/build.gradle.kts             |   2 +
 .../dokka/gradle/ConfigurationExtractor.kt         |   2 +-
 .../jetbrains/dokka/gradle/DokkaCollectorTask.kt   |   8 +-
 .../dokka/gradle/DokkaSourceSetIDFactory.kt        |  10 +
 .../kotlin/org/jetbrains/dokka/gradle/DokkaTask.kt |  36 ++--
 .../dokka/gradle/configurationImplementations.kt   |  93 +++++++--
 .../main/kotlin/org/jetbrains/dokka/gradle/main.kt |   4 +-
 .../gradle/KotlinDslDokkaTaskConfigurationTest.kt  |  77 ++++++++
 runners/maven-plugin/src/main/kotlin/DokkaMojo.kt  |  14 +-
 .../src/main/kotlin/testApi/context/MockContext.kt |   3 +-
 .../testApi/testRunner/DokkaTestGenerator.kt       |   3 +-
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |  19 +-
 69 files changed, 567 insertions(+), 634 deletions(-)
 delete mode 100644 runners/ant/build.gradle
 delete mode 100644 runners/ant/src/main/kotlin/ant/dokka.kt
 delete mode 100644 runners/ant/src/main/resources/dokka-antlib.xml
 create mode 100644 runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaSourceSetIDFactory.kt

(limited to 'core/src/main/kotlin/plugability')

diff --git a/build.gradle.kts b/build.gradle.kts
index c94faa77..04f4afd4 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -19,7 +19,7 @@ allprojects {
     val language_version: String by project
     tasks.withType(KotlinCompile::class).all {
         kotlinOptions {
-            freeCompilerArgs += "-Xjsr305=strict -Xskip-metadata-version-check"
+            freeCompilerArgs += "-Xjsr305=strict -Xskip-metadata-version-check -Xopt-in=kotlin.RequiresOptIn."
             languageVersion = language_version
             apiVersion = language_version
             jvmTarget = "1.8"
@@ -49,4 +49,4 @@ subprojects {
     }
 }
 
-println("Publication version: $dokka_version")
\ No newline at end of file
+println("Publication version: $dokka_version")
diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index bd632546..be3d6c9b 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -1,8 +1,6 @@
 package org.jetbrains.dokka
 
-import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaConfiguration.PackageOptions
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
 import org.jetbrains.dokka.utilities.DokkaLogger
 
 import java.util.function.BiConsumer
@@ -80,7 +78,6 @@ class DokkaBootstrapImpl : DokkaBootstrap {
     }
 
     private lateinit var generator: DokkaGenerator
-    val gson = Gson()
 
     fun configure(logger: DokkaLogger, configuration: DokkaConfigurationImpl) = with(configuration) {
 
@@ -113,7 +110,7 @@ class DokkaBootstrapImpl : DokkaBootstrap {
 
     override fun configure(logger: BiConsumer<String, String>, serializedConfigurationJSON: String) = configure(
         DokkaProxyLogger(logger),
-        gson.fromJson(serializedConfigurationJSON, DokkaConfigurationImpl::class.java)
+        DokkaConfigurationImpl(serializedConfigurationJSON)
     )
 
     override fun generate() = generator.generate()
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index ce8d229a..ee1adf0b 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -68,7 +68,7 @@ class DokkaGenerator(
     fun createDocumentationModels(
         context: DokkaContext
     ) = context.configuration.sourceSets
-        .flatMap { passConfiguration -> translateSources(passConfiguration, context) }
+        .flatMap { sourceSet -> translateSources(sourceSet, context) }
 
     fun transformDocumentationModelBeforeMerge(
         modulesFromPlatforms: List<DModule>,
diff --git a/core/src/main/kotlin/DokkaMultimoduleBootstrapImpl.kt b/core/src/main/kotlin/DokkaMultimoduleBootstrapImpl.kt
index 6825ce64..70b99f8d 100644
--- a/core/src/main/kotlin/DokkaMultimoduleBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaMultimoduleBootstrapImpl.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka
 
-import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaBootstrapImpl.DokkaProxyLogger
 import org.jetbrains.dokka.utilities.DokkaLogger
 import java.util.function.BiConsumer
@@ -15,11 +14,11 @@ class DokkaMultimoduleBootstrapImpl : DokkaBootstrap {
 
     override fun configure(logger: BiConsumer<String, String>, serializedConfigurationJSON: String) = configure(
         DokkaProxyLogger(logger),
-        Gson().fromJson(serializedConfigurationJSON, DokkaConfigurationImpl::class.java)
+        DokkaConfigurationImpl(serializedConfigurationJSON)
     )
 
     override fun generate() {
         generator.generateAllModulesPage()
     }
 
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index 463d2342..c531ab9a 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -1,6 +1,10 @@
+@file:Suppress("FunctionName")
+
 package org.jetbrains.dokka
 
+import com.google.gson.Gson
 import java.io.File
+import java.io.Serializable
 import java.net.URL
 
 object DokkaDefaults {
@@ -43,6 +47,23 @@ enum class Platform(val key: String) {
     }
 }
 
+data class DokkaSourceSetID(
+    val moduleName: String,
+    val sourceSetName: String
+) : Serializable {
+    override fun toString(): String {
+        return "$moduleName/$sourceSetName"
+    }
+}
+
+fun DokkaConfigurationImpl(json: String): DokkaConfigurationImpl {
+    return Gson().fromJson(json, DokkaConfigurationImpl::class.java)
+}
+
+fun DokkaConfiguration.toJson(): String {
+    return Gson().toJson(this)
+}
+
 interface DokkaConfiguration {
     val outputDir: String
     val format: String
@@ -55,12 +76,12 @@ interface DokkaConfiguration {
     val pluginsConfiguration: Map<String, String>
 
     interface DokkaSourceSet {
-        val moduleName: String
+        val sourceSetID: DokkaSourceSetID
         val displayName: String
-        val sourceSetID: String
+        val moduleDisplayName: String
         val classpath: List<String>
         val sourceRoots: List<SourceRoot>
-        val dependentSourceSets: List<String>
+        val dependentSourceSets: Set<DokkaSourceSetID>
         val samples: List<String>
         val includes: List<String>
         val includeNonPublic: Boolean
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index d3ac9df2..47bd7fe2 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -1,5 +1,6 @@
 package org.jetbrains.dokka
 
+import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import java.io.File
 import java.net.URL
 
@@ -16,12 +17,12 @@ data class DokkaConfigurationImpl(
 ) : DokkaConfiguration
 
 data class DokkaSourceSetImpl(
-    override val moduleName: String,
+    override val moduleDisplayName: String,
     override val displayName: String,
-    override val sourceSetID: String,
+    override val sourceSetID: DokkaSourceSetID,
     override val classpath: List<String>,
     override val sourceRoots: List<SourceRootImpl>,
-    override val dependentSourceSets: List<String>,
+    override val dependentSourceSets: Set<DokkaSourceSetID>,
     override val samples: List<String>,
     override val includes: List<String>,
     override val includeNonPublic: Boolean,
@@ -39,23 +40,23 @@ data class DokkaSourceSetImpl(
     override val noJdkLink: Boolean,
     override val suppressedFiles: List<String>,
     override val analysisPlatform: Platform
-) : DokkaConfiguration.DokkaSourceSet
+) : DokkaSourceSet
 
 data class DokkaModuleDescriptionImpl(
     override val name: String,
     override val path: String,
     override val docFile: String
-): DokkaConfiguration.DokkaModuleDescription
+) : DokkaConfiguration.DokkaModuleDescription
 
 data class SourceRootImpl(
     override val path: String
-): DokkaConfiguration.SourceRoot
+) : DokkaConfiguration.SourceRoot
 
 data class SourceLinkDefinitionImpl(
     override val path: String,
     override val url: String,
     override val lineSuffix: String?
-): DokkaConfiguration.SourceLinkDefinition {
+) : DokkaConfiguration.SourceLinkDefinition {
     companion object {
         fun parseSourceLinkDefinition(srcLink: String): SourceLinkDefinitionImpl {
             val (path, urlAndLine) = srcLink.split('=')
@@ -73,9 +74,10 @@ data class PackageOptionsImpl(
     override val reportUndocumented: Boolean?,
     override val skipDeprecated: Boolean,
     override val suppress: Boolean
-): DokkaConfiguration.PackageOptions
+) : DokkaConfiguration.PackageOptions
 
 
-data class ExternalDocumentationLinkImpl(override val url: URL,
-                                         override val packageListUrl: URL
+data class ExternalDocumentationLinkImpl(
+    override val url: URL,
+    override val packageListUrl: URL
 ) : DokkaConfiguration.ExternalDocumentationLink
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index fe472b12..7ead43b8 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -82,4 +82,4 @@ inline fun <reified T : DokkaPlugin, reified R : ConfigurableBlock> configuratio
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
index 426ffdde..e723768c 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/KotlinAnalysis.kt
@@ -3,6 +3,7 @@
 package org.jetbrains.dokka.analysis
 
 import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
+import org.jetbrains.dokka.DokkaSourceSetID
 import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
 
@@ -21,7 +22,7 @@ fun KotlinAnalysis(context: DokkaContext): KotlinAnalysis {
 
 interface KotlinAnalysis : SourceSetDependent<EnvironmentAndFacade> {
     override fun get(key: DokkaSourceSet): EnvironmentAndFacade
-    operator fun get(sourceSetID: String): EnvironmentAndFacade
+    operator fun get(sourceSetID: DokkaSourceSetID): EnvironmentAndFacade
 }
 
 internal class KotlinAnalysisImpl(
@@ -32,7 +33,7 @@ internal class KotlinAnalysisImpl(
         return environments[key] ?: throw IllegalStateException("Missing EnvironmentAndFacade for sourceSet $key")
     }
 
-    override fun get(sourceSetID: String): EnvironmentAndFacade {
+    override fun get(sourceSetID: DokkaSourceSetID): EnvironmentAndFacade {
         return environments.entries.first { (sourceSet, _) -> sourceSet.sourceSetID == sourceSetID }.value
     }
 }
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index de892bb1..f8fa3b2e 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -94,7 +94,7 @@ open class HtmlRenderer(
             group.sourceSets.forEach {
                 button(classes = "platform-tag platform-selector") {
                     attributes["data-active"] = ""
-                    attributes["data-filter"] = it.sourceSetID
+                    attributes["data-filter"] = it.sourceSetID.toString()
                     when (it.analysisPlatform.key) {
                         "common" -> classes = classes + "common-like"
                         "native" -> classes = classes + "native-like"
@@ -168,10 +168,10 @@ open class HtmlRenderer(
                     attributes["data-toggle-list"] = "data-toggle-list"
                     contents.forEachIndexed { index, pair ->
                         button(classes = "platform-bookmark") {
-                            attributes["data-filterable-current"] = pair.first.sourceSetID
-                            attributes["data-filterable-set"] = pair.first.sourceSetID
+                            attributes["data-filterable-current"] = pair.first.sourceSetID.toString()
+                            attributes["data-filterable-set"] = pair.first.sourceSetID.toString()
                             if (index == 0) attributes["data-active"] = ""
-                            attributes["data-toggle"] = pair.first.sourceSetID
+                            attributes["data-toggle"] = pair.first.sourceSetID.toString()
                             when (
                                 pair.first.analysisPlatform.key
                                 ) {
@@ -180,7 +180,7 @@ open class HtmlRenderer(
                                 "jvm" -> classes = classes + "jvm-like"
                                 "js" -> classes = classes + "js-like"
                             }
-                            attributes["data-toggle"] = pair.first.sourceSetID
+                            attributes["data-toggle"] = pair.first.sourceSetID.toString()
                             text(pair.first.displayName)
                         }
                     }
@@ -212,7 +212,7 @@ open class HtmlRenderer(
             }.map {
                 it to createHTML(prettyPrint = false).div(classes = "content sourceset-depenent-content") {
                     if (counter++ == 0) attributes["data-active"] = ""
-                    attributes["data-togglable"] = it.sourceSetID
+                    attributes["data-togglable"] = it.sourceSetID.toString()
                     unsafe {
                         +html
                     }
@@ -249,10 +249,10 @@ open class HtmlRenderer(
             consumer.onTagContentUnsafe {
                 +createHTML().div("divergent-group") {
                     attributes["data-filterable-current"] = groupedDivergent.keys.joinToString(" ") {
-                        it.sourceSetID
+                        it.sourceSetID.toString()
                     }
                     attributes["data-filterable-set"] = groupedDivergent.keys.joinToString(" ") {
-                        it.sourceSetID
+                        it.sourceSetID.toString()
                     }
 
                     val divergentForPlatformDependent = groupedDivergent.map { (sourceSet, elements) ->
@@ -353,10 +353,10 @@ open class HtmlRenderer(
                     div(classes = "table-row") {
                         if (!style.contains(MultimoduleTable)) {
                             attributes["data-filterable-current"] = node.sourceSets.joinToString(" ") {
-                                it.sourceSetID
+                                it.sourceSetID.toString()
                             }
                             attributes["data-filterable-set"] = node.sourceSets.joinToString(" ") {
-                                it.sourceSetID
+                                it.sourceSetID.toString()
                             }
                         }
 
@@ -728,4 +728,4 @@ private fun String.stripDiv() = drop(5).dropLast(6) // TODO: Find a way to do it
 private val PageNode.isNavigable: Boolean
     get() = this !is RendererSpecificPage || strategy != RenderingStrategy.DoNothing
 
-fun PropertyContainer<ContentNode>.extraHtmlAttributes() = allOfType<SimpleAttr>()
\ No newline at end of file
+fun PropertyContainer<ContentNode>.extraHtmlAttributes() = allOfType<SimpleAttr>()
diff --git a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
index f042eae3..2a242948 100644
--- a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
+++ b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka.base.signatures
 
-import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.*
@@ -142,4 +141,4 @@ interface JvmSignatureUtils {
 sealed class AtStrategy
 object All : AtStrategy()
 object OnlyOnce : AtStrategy()
-object Never : AtStrategy()
\ No newline at end of file
+object Never : AtStrategy()
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
index c3cc4d38..ff05beed 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
@@ -9,11 +9,9 @@ import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMergeDocumentableTransformer {
 
     override fun invoke(modules: List<DModule>) = modules.map { original ->
-        val passOptions = original.sourceSets.single()
-        val packageOptions = passOptions.perPackageOptions
-        original.let {
-            DocumentableVisibilityFilter(packageOptions, passOptions).processModule(it)
-        }
+        val sourceSet = original.sourceSets.single()
+        val packageOptions = sourceSet.perPackageOptions
+        DocumentableVisibilityFilter(packageOptions, sourceSet).processModule(original)
     }
 
     private class DocumentableVisibilityFilter(
@@ -45,7 +43,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
 
         private fun filterPackages(packages: List<DPackage>): Pair<Boolean, List<DPackage>> {
             var packagesListChanged = false
-            val filteredPackages = packages.mapNotNull {
+            val filteredPackages = packages.map {
                 var modified = false
                 val functions = filterFunctions(it.functions).let { (listModified, list) ->
                     modified = modified || listModified
@@ -326,4 +324,4 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
             return Pair(classlikesListChanged, filteredClasslikes)
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
index 3fd0081a..61abfbd7 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/EmptyPackagesFilterTransformer.kt
@@ -14,9 +14,9 @@ class EmptyPackagesFilterTransformer(val context: DokkaContext) : PreMergeDocume
     }
 
     private class EmptyPackagesFilter(
-        val passOptions: DokkaConfiguration.DokkaSourceSet
+        val sourceSet: DokkaConfiguration.DokkaSourceSet
     ) {
-        fun DPackage.shouldBeSkipped() = passOptions.skipEmptyPackages &&
+        fun DPackage.shouldBeSkipped() = sourceSet.skipEmptyPackages &&
                 functions.isEmpty() &&
                 properties.isEmpty() &&
                 classlikes.isEmpty()
@@ -25,4 +25,4 @@ class EmptyPackagesFilterTransformer(val context: DokkaContext) : PreMergeDocume
             packages = module.packages.filter { !it.shouldBeSkipped() }
         )
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
index 1f718a7c..a0800da8 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ModuleAndPackageDocumentationTransformer.kt
@@ -1,12 +1,10 @@
 package org.jetbrains.dokka.base.transformers.documentables
 
-import org.jetbrains.dokka.analysis.EnvironmentAndFacade
 import org.jetbrains.dokka.analysis.KotlinAnalysis
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.parsers.MarkdownParser
-import org.jetbrains.dokka.model.SourceSetDependent
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.transformers.documentation.PreMergeDocumentableTransformer
 import org.jetbrains.kotlin.name.FqName
@@ -24,7 +22,7 @@ internal class ModuleAndPackageDocumentationTransformer(
         val modulesAndPackagesDocumentation =
             context.configuration.sourceSets
                 .map {
-                    Pair(it.moduleName, it) to
+                    Pair(it.moduleDisplayName, it) to
                             it.includes.map { Paths.get(it) }
                                 .also {
                                     it.forEach {
diff --git a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
index b39715a7..41dea1a2 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/samples/SamplesTransformer.kt
@@ -67,7 +67,7 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
         analysis: Map<DokkaSourceSet, EnvironmentAndFacade>
     ): ContentNode {
         val facade = analysis[platform]?.facade
-            ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleName}") }
+            ?: return this.also { context.logger.warn("Cannot resolve facade for platform ${platform.moduleDisplayName}") }
         val psiElement = fqNameToPsiElement(facade, fqName)
             ?: return this.also { context.logger.warn("Cannot find PsiElement corresponding to $fqName") }
         val imports =
@@ -147,4 +147,4 @@ abstract class SamplesTransformer(val context: DokkaContext) : PageTransformer {
             style = styles + ContentStyle.RunnableSample + TextStyle.Monospace,
             extra = extra
         )
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index 9cdd251c..b0374014 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies
 import org.jetbrains.kotlin.idea.kdoc.findKDoc
-import org.jetbrains.kotlin.idea.kdoc.isBoringBuiltinClass
 import org.jetbrains.kotlin.load.kotlin.toSourceElement
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
@@ -36,7 +35,6 @@ import org.jetbrains.kotlin.resolve.constants.KClassValue.Value.NormalClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces
-import org.jetbrains.kotlin.resolve.jvm.isInlineClassThatRequiresMangling
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
@@ -71,7 +69,7 @@ class DefaultDescriptorToDocumentableTranslator(
                     DRIWithPlatformInfo(DRI.topLevel, emptyMap())
                 )
             }
-        }.let { DModule(sourceSet.moduleName, it, emptyMap(), null, setOf(sourceSet)) }
+        }.let { DModule(sourceSet.moduleDisplayName, it, emptyMap(), null, setOf(sourceSet)) }
     }
 }
 
diff --git a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
index 76f8319d..5a55e3ec 100644
--- a/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/psi/DefaultPsiToDocumentableTranslator.kt
@@ -68,7 +68,7 @@ class DefaultPsiToDocumentableTranslator(
                 context.logger
             )
         return DModule(
-            sourceSet.moduleName,
+            sourceSet.moduleDisplayName,
             psiFiles.mapNotNull { it.safeAs<PsiJavaFile>() }.groupBy { it.packageName }.map { (packageName, psiFiles) ->
                 val dri = DRI(packageName = packageName)
                 DPackage(
diff --git a/plugins/base/src/test/kotlin/basic/DRITest.kt b/plugins/base/src/test/kotlin/basic/DRITest.kt
index 1f4c7d93..559a2dbf 100644
--- a/plugins/base/src/test/kotlin/basic/DRITest.kt
+++ b/plugins/base/src/test/kotlin/basic/DRITest.kt
@@ -5,19 +5,19 @@ import org.jetbrains.dokka.links.Callable
 import org.jetbrains.dokka.links.Nullable
 import org.jetbrains.dokka.links.TypeConstructor
 import org.jetbrains.dokka.model.*
-import org.jetbrains.dokka.pages.*
-import org.jetbrains.dokka.pages.dfs
-import org.junit.jupiter.api.Assertions.assertEquals
+import org.jetbrains.dokka.pages.ClasslikePageNode
+import org.jetbrains.dokka.pages.ContentPage
+import org.jetbrains.dokka.pages.MemberPageNode
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
-
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 
 class DRITest : AbstractCoreTest() {
     @Test
     fun issue634() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -52,8 +52,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun issue634WithImmediateNullableSelf() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -82,8 +82,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun issue634WithGenericNullableReceiver() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -112,8 +112,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun issue642WithStarAndAny() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     analysisPlatform = "js"
                     sourceRoots = listOf("src/")
                 }
@@ -171,8 +171,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun driForGenericClass(){
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -201,8 +201,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun driForGenericFunction(){
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                     classpath = listOfNotNull(jvmStdlibPath)
                 }
@@ -243,8 +243,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun driForFunctionNestedInsideInnerClass() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                     classpath = listOfNotNull(jvmStdlibPath)
                 }
@@ -280,8 +280,8 @@ class DRITest : AbstractCoreTest() {
     @Test
     fun driForGenericExtensionFunction(){
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
diff --git a/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt b/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
index 5cc17bf3..bceb79ae 100644
--- a/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
+++ b/plugins/base/src/test/kotlin/basic/DokkaBasicTests.kt
@@ -11,8 +11,8 @@ class DokkaBasicTests : AbstractCoreTest() {
     @Test
     fun basic1() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
             }
@@ -39,4 +39,4 @@ class DokkaBasicTests : AbstractCoreTest() {
 
     private fun ModulePageNode.getClasslikeToMemberMap() =
         this.parentMap.filterValues { it is ClasslikePageNode }.entries.groupBy({ it.value }) { it.key }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt b/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
index d548b75b..9d2c5825 100644
--- a/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
+++ b/plugins/base/src/test/kotlin/basic/FailOnWarningTest.kt
@@ -14,8 +14,8 @@ class FailOnWarningTest : AbstractCoreTest() {
     fun `throws exception if one or more warnings were emitted`() {
         val configuration = dokkaConfiguration {
             failOnWarning = true
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -39,8 +39,8 @@ class FailOnWarningTest : AbstractCoreTest() {
     fun `throws exception if one or more error were emitted`() {
         val configuration = dokkaConfiguration {
             failOnWarning = true
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -66,8 +66,8 @@ class FailOnWarningTest : AbstractCoreTest() {
 
         val configuration = dokkaConfiguration {
             failOnWarning = true
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -88,8 +88,8 @@ class FailOnWarningTest : AbstractCoreTest() {
     fun `does not throw if disabled`() {
         val configuration = dokkaConfiguration {
             failOnWarning = false
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -115,4 +115,4 @@ private class ZeroErrorOrWarningCountDokkaLogger(
 ) : DokkaLogger by logger {
     override var warningsCount: Int = 0
     override var errorsCount: Int = 0
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt b/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
index 7add4119..bf78b847 100644
--- a/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
+++ b/plugins/base/src/test/kotlin/content/annotations/ContentForAnnotationsTest.kt
@@ -14,8 +14,8 @@ class ContentForAnnotationsTest : AbstractCoreTest() {
 
 
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
@@ -218,4 +218,4 @@ class ContentForAnnotationsTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/content/annotations/DepredatedAndSinceKotlinTest.kt b/plugins/base/src/test/kotlin/content/annotations/DepredatedAndSinceKotlinTest.kt
index 99ec25c5..69de1bcd 100644
--- a/plugins/base/src/test/kotlin/content/annotations/DepredatedAndSinceKotlinTest.kt
+++ b/plugins/base/src/test/kotlin/content/annotations/DepredatedAndSinceKotlinTest.kt
@@ -3,19 +3,17 @@ package content.annotations
 
 import matchers.content.*
 import org.jetbrains.dokka.pages.ContentPage
-import org.jetbrains.dokka.pages.PackagePageNode
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.junit.jupiter.api.Test
 import utils.ParamAttributes
 import utils.bareSignature
-import utils.propertySignature
 
 
 class DepredatedAndSinceKotlinTest : AbstractCoreTest() {
 
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
@@ -102,4 +100,4 @@ class DepredatedAndSinceKotlinTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
index f6e80891..a9689bc5 100644
--- a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
+++ b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
@@ -17,8 +17,8 @@ import utils.*
 
 class ContentForParamsTest : AbstractCoreTest() {
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
diff --git a/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt b/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
index 696c3032..24970660 100644
--- a/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
+++ b/plugins/base/src/test/kotlin/content/seealso/ContentForSeeAlsoTest.kt
@@ -11,8 +11,8 @@ import utils.unnamedTag
 
 class ContentForSeeAlsoTest : AbstractCoreTest() {
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
@@ -456,4 +456,4 @@ class ContentForSeeAlsoTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt b/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
index 6cb8b0f4..cabe822d 100644
--- a/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
+++ b/plugins/base/src/test/kotlin/content/signatures/ContentForSignaturesTest.kt
@@ -14,8 +14,8 @@ import utils.typealiasSignature
 class ContentForSignaturesTest : AbstractCoreTest() {
 
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
                 includeNonPublic = true
diff --git a/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt b/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
index d203025b..c2fbd26f 100644
--- a/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
+++ b/plugins/base/src/test/kotlin/content/signatures/SkippingParenthesisForConstructorsTest.kt
@@ -8,8 +8,8 @@ import utils.functionSignature
 
 class ConstructorsSignaturesTest : AbstractCoreTest() {
     private val testConfiguration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/")
                 analysisPlatform = "jvm"
             }
@@ -190,4 +190,4 @@ class ConstructorsSignaturesTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/enums/EnumsTest.kt b/plugins/base/src/test/kotlin/enums/EnumsTest.kt
index be910b5c..6a973f8e 100644
--- a/plugins/base/src/test/kotlin/enums/EnumsTest.kt
+++ b/plugins/base/src/test/kotlin/enums/EnumsTest.kt
@@ -14,8 +14,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun basicEnum() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -45,8 +45,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun enumWithCompanion() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -90,8 +90,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun enumWithConstructor() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -136,8 +136,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun enumWithMethods() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -179,8 +179,8 @@ class EnumsTest : AbstractCoreTest() {
     @Test
     fun enumWithAnnotationsOnEntries(){
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
diff --git a/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt b/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
index 3b69a54e..4dfdc410 100644
--- a/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
+++ b/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
@@ -15,8 +15,8 @@ abstract class AbstractExpectTest(
     protected fun generateOutput(path: Path, outFormat: String): Path? {
         val config = dokkaConfiguration {
             format = outFormat
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf(path.toAbsolutePath().asString())
                 }
             }
@@ -101,4 +101,4 @@ abstract class AbstractExpectTest(
         ret?.let { Files.list(it).forEach { f -> f.copyRecursively(out.resolve(f.fileName)) } }
     }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/filter/DeprecationFilterTest.kt b/plugins/base/src/test/kotlin/filter/DeprecationFilterTest.kt
index c15e53e8..c8b9f2d4 100644
--- a/plugins/base/src/test/kotlin/filter/DeprecationFilterTest.kt
+++ b/plugins/base/src/test/kotlin/filter/DeprecationFilterTest.kt
@@ -9,8 +9,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `function with false global skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     skipDeprecated = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -39,8 +39,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `deprecated function with false global skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     skipDeprecated = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -69,8 +69,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `deprecated function with true global skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     skipDeprecated = true
                 }
@@ -99,8 +99,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `deprecated function with false global true package skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     skipDeprecated = false
                     perPackageOptions = mutableListOf(
@@ -136,8 +136,8 @@ class DeprecationFilterTest : AbstractCoreTest() {
     @Test
     fun `deprecated function with true global false package skipDeprecated`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     skipDeprecated = true
                     perPackageOptions = mutableListOf(
@@ -170,4 +170,4 @@ class DeprecationFilterTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/filter/EmptyPackagesFilterTest.kt b/plugins/base/src/test/kotlin/filter/EmptyPackagesFilterTest.kt
index 7d96541b..e5b9e9c2 100644
--- a/plugins/base/src/test/kotlin/filter/EmptyPackagesFilterTest.kt
+++ b/plugins/base/src/test/kotlin/filter/EmptyPackagesFilterTest.kt
@@ -1,6 +1,5 @@
 package filter
 
-import org.jetbrains.dokka.PackageOptionsImpl
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Test
@@ -9,8 +8,8 @@ class EmptyPackagesFilterTest : AbstractCoreTest() {
     @Test
     fun `empty package with false skipEmptyPackages`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     skipEmptyPackages = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -37,8 +36,8 @@ class EmptyPackagesFilterTest : AbstractCoreTest() {
     @Test
     fun `empty package with true skipEmptyPackages`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     skipEmptyPackages = true
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -61,4 +60,4 @@ class EmptyPackagesFilterTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt b/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
index 5e8e33dc..192de449 100644
--- a/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
+++ b/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
@@ -9,8 +9,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `public function with false global includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     includeNonPublic = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -39,8 +39,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `private function with false global includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     includeNonPublic = false
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                 }
@@ -69,8 +69,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `private function with true global includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     includeNonPublic = true
                 }
@@ -99,8 +99,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `private function with false global true package includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     includeNonPublic = false
                     perPackageOptions = mutableListOf(
@@ -136,8 +136,8 @@ class VisibilityFilterTest : AbstractCoreTest() {
     @Test
     fun `private function with true global false package includeNonPublic`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/basic/Test.kt")
                     includeNonPublic = true
                     perPackageOptions = mutableListOf(
@@ -170,4 +170,4 @@ class VisibilityFilterTest : AbstractCoreTest() {
              }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/issues/IssuesTest.kt b/plugins/base/src/test/kotlin/issues/IssuesTest.kt
index f67229b7..7b065349 100644
--- a/plugins/base/src/test/kotlin/issues/IssuesTest.kt
+++ b/plugins/base/src/test/kotlin/issues/IssuesTest.kt
@@ -34,8 +34,8 @@ class IssuesTest : AbstractModelTest("/src/main/kotlin/issues/Test.kt", "issues"
             |}
         """,
             configuration = dokkaConfiguration {
-                passes {
-                    pass {
+                sourceSets {
+                    sourceSet {
                         sourceRoots = listOf("src/")
                         classpath = listOfNotNull(jvmStdlibPath)
                     }
@@ -70,4 +70,4 @@ class IssuesTest : AbstractModelTest("/src/main/kotlin/issues/Test.kt", "issues"
     //        }
     //    }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
index 191df066..2775fcf4 100644
--- a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
+++ b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
@@ -23,23 +23,23 @@ class LinkableContentTest : AbstractCoreTest() {
         val includesDir = getTestDataDir("linkable/includes").toAbsolutePath()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "js"
                     sourceRoots = listOf("jsMain", "commonMain", "jvmAndJsSecondCommonMain").map {
                         Paths.get("$testDataDir/$it/kotlin").toString()
                     }
-                    sourceSetID = "js"
+                    name = "js"
                     includes = listOf(Paths.get("$includesDir/include2.md").toString())
                 }
-                pass {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "jvm"
                     sourceRoots = listOf("jvmMain", "commonMain", "jvmAndJsSecondCommonMain").map {
                         Paths.get("$testDataDir/$it/kotlin").toString()
                     }
-                    sourceSetID = "jvm"
+                    name = "jvm"
                     includes = listOf(Paths.get("$includesDir/include1.md").toString())
                 }
             }
@@ -62,8 +62,8 @@ class LinkableContentTest : AbstractCoreTest() {
         val testDataDir = getTestDataDir("linkable/sources").toAbsolutePath()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "js"
                     sourceRoots = listOf("$testDataDir/jsMain/kotlin")
@@ -74,9 +74,9 @@ class LinkableContentTest : AbstractCoreTest() {
                             lineSuffix = "#L"
                         )
                     )
-                    sourceSetID = "js"
+                    name = "js"
                 }
-                pass {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "jvm"
                     sourceRoots = listOf("$testDataDir/jvmMain/kotlin")
@@ -87,7 +87,7 @@ class LinkableContentTest : AbstractCoreTest() {
                             lineSuffix = "#L"
                         )
                     )
-                    sourceSetID = "jvm"
+                    name = "jvm"
                 }
             }
         }
@@ -127,19 +127,19 @@ class LinkableContentTest : AbstractCoreTest() {
         val testDataDir = getTestDataDir("linkable/samples").toAbsolutePath()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "js"
                     sourceRoots = listOf("$testDataDir/jsMain/kotlin")
-                    sourceSetID = "js"
+                    name = "js"
                     samples = listOf("$testDataDir/jsMain/resources/Samples.kt")
                 }
-                pass {
+                sourceSet {
                     moduleName = "example"
                     analysisPlatform = "jvm"
                     sourceRoots = listOf("$testDataDir/jvmMain/kotlin")
-                    sourceSetID = "jvm"
+                    name = "jvm"
                     samples = listOf("$testDataDir/jvmMain/resources/Samples.kt")
                 }
             }
@@ -196,11 +196,11 @@ class LinkableContentTest : AbstractCoreTest() {
             |
         """.trimIndent(),
             dokkaConfiguration {
-                passes {
-                    pass {
+                sourceSets {
+                    sourceSet {
                         sourceRoots = listOf("src/")
                         analysisPlatform = "jvm"
-                        sourceSetID = "js"
+                        name = "js"
                     }
                 }
             }
@@ -222,4 +222,4 @@ class LinkableContentTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/locationProvider/DefaultLocationProviderTest.kt b/plugins/base/src/test/kotlin/locationProvider/DefaultLocationProviderTest.kt
index 1bc3ea29..a219fb04 100644
--- a/plugins/base/src/test/kotlin/locationProvider/DefaultLocationProviderTest.kt
+++ b/plugins/base/src/test/kotlin/locationProvider/DefaultLocationProviderTest.kt
@@ -10,8 +10,8 @@ class DefaultLocationProviderTest: AbstractCoreTest() {
     @Test
     fun `#644 same directory for module and package`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -38,4 +38,4 @@ class DefaultLocationProviderTest: AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/markdown/KDocTest.kt b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
index 218f7244..f5b29322 100644
--- a/plugins/base/src/test/kotlin/markdown/KDocTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
@@ -9,8 +9,8 @@ import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 abstract class KDocTest : AbstractCoreTest() {
 
     private val configuration = dokkaConfiguration {
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src/main/kotlin/example/Test.kt")
             }
         }
@@ -44,4 +44,4 @@ abstract class KDocTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/markdown/LinkTest.kt b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
index ddcef5db..8e4e588e 100644
--- a/plugins/base/src/test/kotlin/markdown/LinkTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
@@ -13,8 +13,8 @@ class LinkTest : AbstractCoreTest() {
     @Test
     fun linkToClassLoader() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/parser")
                 }
             }
@@ -46,8 +46,8 @@ class LinkTest : AbstractCoreTest() {
     @Test
     fun returnTypeShouldHaveLinkToOuterClassFromInner() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin")
                 }
             }
@@ -75,4 +75,4 @@ class LinkTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/model/InheritorsTest.kt b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
index f5517abb..503cf50c 100644
--- a/plugins/base/src/test/kotlin/model/InheritorsTest.kt
+++ b/plugins/base/src/test/kotlin/model/InheritorsTest.kt
@@ -44,12 +44,12 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
     @Test
     fun multiplatform() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("common/src/", "jvm/src/")
                     analysisPlatform = "jvm"
                 }
-                pass {
+                sourceSet {
                     sourceRoots = listOf("common/src/", "js/src/")
                     analysisPlatform = "js"
                 }
@@ -92,4 +92,4 @@ class InheritorsTest : AbstractModelTest("/src/main/kotlin/inheritors/Test.kt",
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/model/PropertyTest.kt b/plugins/base/src/test/kotlin/model/PropertyTest.kt
index e384b920..af952b43 100644
--- a/plugins/base/src/test/kotlin/model/PropertyTest.kt
+++ b/plugins/base/src/test/kotlin/model/PropertyTest.kt
@@ -169,8 +169,8 @@ class PropertyTest : AbstractModelTest("/src/main/kotlin/property/Test.kt", "pro
                 |@Strictfp var property = "test"
                 """,
             configuration = dokkaConfiguration {
-                passes {
-                    pass {
+                sourceSets {
+                    sourceSet {
                         sourceRoots = listOf("src/")
                         classpath = listOfNotNull(jvmStdlibPath)
                     }
@@ -262,4 +262,4 @@ class PropertyTest : AbstractModelTest("/src/main/kotlin/property/Test.kt", "pro
 //    }
 //
 //}
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt b/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
index 5facd194..b3ac7b07 100644
--- a/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
+++ b/plugins/base/src/test/kotlin/multiplatform/BasicMultiplatformTest.kt
@@ -11,8 +11,8 @@ class BasicMultiplatformTest : AbstractCoreTest() {
         val testDataDir = getTestDataDir("multiplatform/basicMultiplatformTest").toAbsolutePath()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("$testDataDir/jvmMain/")
                 }
             }
@@ -28,8 +28,8 @@ class BasicMultiplatformTest : AbstractCoreTest() {
     @Test
     fun inlineTestExample() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/multiplatform/Test.kt")
                 }
             }
@@ -51,4 +51,4 @@ class BasicMultiplatformTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
index 6ef38aa9..935b9377 100644
--- a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
+++ b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
@@ -39,8 +39,8 @@ class PageNodeMergerTest : AbstractCoreTest() {
     fun sameNameStrategyTest() {
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
                 }
             }
@@ -82,8 +82,8 @@ class PageNodeMergerTest : AbstractCoreTest() {
         val strList: MutableList<String> = mutableListOf()
 
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/pageMerger/Test.kt")
                 }
             }
@@ -123,4 +123,4 @@ class PageNodeMergerTest : AbstractCoreTest() {
 
     fun PageNode.childrenRec(): List<PageNode> = listOf(this) + children.flatMap { it.childrenRec() }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
index 6ceb805b..d4778a8e 100644
--- a/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/DivergentTest.kt
@@ -12,14 +12,14 @@ class DivergentTest : RenderingOnlyTestBase() {
     private val js = defaultSourceSet.copy(
         "root",
         "JS",
-        "js",
+        defaultSourceSet.sourceSetID.copy(sourceSetName = "js"),
         analysisPlatform = Platform.js,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
     private val jvm = defaultSourceSet.copy(
         "root",
         "JVM",
-        "jvm",
+        defaultSourceSet.sourceSetID.copy(sourceSetName = "jvm"),
 
         analysisPlatform = Platform.jvm,
         sourceRoots = listOf(SourceRootImpl("pl1"))
@@ -27,7 +27,7 @@ class DivergentTest : RenderingOnlyTestBase() {
     private val native = defaultSourceSet.copy(
         "root",
         "NATIVE",
-        "native",
+        defaultSourceSet.sourceSetID.copy(sourceSetName = "native"),
         analysisPlatform = Platform.native,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
@@ -344,4 +344,4 @@ class DivergentTest : RenderingOnlyTestBase() {
             Div(Div("b-", Span()), Div(Div(Div(("b")))), "ab+")
         )
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
index c868cfd5..ea1ea9ae 100644
--- a/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/SourceSetDependentHintTest.kt
@@ -15,21 +15,21 @@ class SourceSetDependentHintTest : RenderingOnlyTestBase() {
     private val pl1 = defaultSourceSet.copy(
         "root",
         "pl1",
-        "pl1",
+        defaultSourceSet.sourceSetID.copy(sourceSetName =  "pl1"),
         analysisPlatform = Platform.js,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
     private val pl2 = defaultSourceSet.copy(
         "root",
         "pl2",
-        "pl2",
+        defaultSourceSet.sourceSetID.copy(sourceSetName =  "pl2"),
         analysisPlatform = Platform.jvm,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
     private val pl3 = defaultSourceSet.copy(
         "root",
         "pl3",
-        "pl3",
+        defaultSourceSet.sourceSetID.copy(sourceSetName =  "pl3"),
         analysisPlatform = Platform.native,
         sourceRoots = listOf(SourceRootImpl("pl1"))
     )
@@ -135,4 +135,4 @@ class SourceSetDependentHintTest : RenderingOnlyTestBase() {
         HtmlRenderer(context).render(page)
         renderedContent.match(Div(Div(Div("a")), Div(Div("b"))))
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
index 771cabaa..a9be1cfd 100644
--- a/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/defaultSourceSet.kt
@@ -1,15 +1,16 @@
 package renderers.html
 
+import org.jetbrains.dokka.DokkaSourceSetID
 import org.jetbrains.dokka.DokkaSourceSetImpl
 import org.jetbrains.dokka.Platform
 
 internal val defaultSourceSet = DokkaSourceSetImpl(
-    moduleName = "DEFAULT",
+    moduleDisplayName = "DEFAULT",
     displayName = "DEFAULT",
-    sourceSetID = "DEFAULT",
+    sourceSetID = DokkaSourceSetID("DEFAULT", "DEFAULT"),
     classpath = emptyList(),
     sourceRoots = emptyList(),
-    dependentSourceSets = emptyList(),
+    dependentSourceSets = emptySet(),
     samples = emptyList(),
     includes = emptyList(),
     includeNonPublic = false,
@@ -27,4 +28,4 @@ internal val defaultSourceSet = DokkaSourceSetImpl(
     noJdkLink = false,
     suppressedFiles = emptyList(),
     analysisPlatform = Platform.DEFAULT
-)
\ No newline at end of file
+)
diff --git a/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt b/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
index be87813b..4f8a834b 100644
--- a/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
+++ b/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
@@ -26,8 +26,8 @@ class ResourceLinksTest : AbstractCoreTest() {
     @Test
     fun resourceLinksTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/test/Test.kt")
                 }
             }
@@ -68,4 +68,4 @@ class ResourceLinksTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt b/plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt
index e66490c1..d8e057da 100644
--- a/plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt
+++ b/plugins/base/src/test/kotlin/transformerBuilders/PageTransformerBuilderTest.kt
@@ -21,8 +21,8 @@ class PageTransformerBuilderTest : AbstractCoreTest() {
     @Test
     fun scannerTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/transformerBuilder/Test.kt")
                 }
             }
@@ -58,8 +58,8 @@ class PageTransformerBuilderTest : AbstractCoreTest() {
     @Test
     fun mapperTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/transformerBuilder/Test.kt")
                 }
             }
@@ -98,8 +98,8 @@ class PageTransformerBuilderTest : AbstractCoreTest() {
     @Test
     fun structureTransformerTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/kotlin/transformerBuilder/Test.kt")
                 }
             }
diff --git a/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt b/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt
index 523813fc..72948372 100644
--- a/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt
+++ b/plugins/base/src/test/kotlin/transformers/ReportUndocumentedTransformerTest.kt
@@ -12,8 +12,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented class gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -39,8 +39,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented non-public class does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -65,8 +65,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented function gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -95,8 +95,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented property gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -125,8 +125,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented primary constructor does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -153,8 +153,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `data class component functions do not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin")
                 }
@@ -183,8 +183,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented secondary constructor gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -213,8 +213,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented inherited function does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -246,8 +246,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `undocumented inherited property does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -279,8 +279,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `overridden function does not get reported when super is documented`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -315,8 +315,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `overridden property does not get reported when super is documented`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -349,10 +349,10 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     }
 
     @Test
-    fun `report disabled by pass configuration`() {
+    fun `report disabled by source set`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = false
                     sourceRoots = listOf("src/main/kotlin/Test.kt")
                 }
@@ -377,8 +377,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `report enabled by package configuration`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     perPackageOptions += packageOptions(
                         prefix = "sample",
                         reportUndocumented = true,
@@ -407,8 +407,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `report enabled by more specific package configuration`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     perPackageOptions += packageOptions(
                         prefix = "sample",
                         reportUndocumented = false,
@@ -445,8 +445,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `report disabled by more specific package configuration`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     perPackageOptions += packageOptions(
                         prefix = "sample",
                         reportUndocumented = true,
@@ -483,22 +483,22 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `multiplatform undocumented class gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                val commonMain = sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.common.toString()
-                    sourceSetID = "commonMain"
+                    name = "commonMain"
                     displayName = "commonMain"
                     sourceRoots = listOf("src/commonMain/kotlin")
                 }
 
-                pass {
+                sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.jvm.toString()
-                    sourceSetID = "jvmMain"
+                    name = "jvmMain"
                     displayName = "jvmMain"
                     sourceRoots = listOf("src/jvmMain/kotlin")
-                    dependentSourceSets = listOf("commonMain")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
                 }
             }
         }
@@ -526,22 +526,22 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `multiplatform undocumented class does not get reported if expect is documented`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                val commonMain = sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.common.toString()
-                    sourceSetID = "commonMain"
+                    name = "commonMain"
                     displayName = "commonMain"
                     sourceRoots = listOf("src/commonMain/kotlin")
                 }
 
-                pass {
+                sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.jvm.toString()
-                    sourceSetID = "jvmMain"
+                    name = "jvmMain"
                     displayName = "jvmMain"
                     sourceRoots = listOf("src/jvmMain/kotlin")
-                    dependentSourceSets = listOf("commonMain")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
                 }
             }
         }
@@ -568,31 +568,31 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `multiplatform undocumented function gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                val commonMain = sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.common.toString()
-                    sourceSetID = "commonMain"
+                    name = "commonMain"
                     displayName = "commonMain"
                     sourceRoots = listOf("src/commonMain/kotlin")
                 }
 
-                pass {
+                sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.jvm.toString()
-                    sourceSetID = "jvmMain"
+                    name = "jvmMain"
                     displayName = "jvmMain"
                     sourceRoots = listOf("src/jvmMain/kotlin")
-                    dependentSourceSets = listOf("commonMain")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
                 }
 
-                pass {
+                sourceSet {
                     reportUndocumented = true
                     analysisPlatform = Platform.native.toString()
-                    sourceSetID = "macosMain"
+                    name = "macosMain"
                     displayName = "macosMain"
                     sourceRoots = listOf("src/macosMain/kotlin")
-                    dependentSourceSets = listOf("commonMain")
+                    dependentSourceSets = setOf(commonMain.sourceSetID)
                 }
             }
         }
@@ -625,8 +625,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented class gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -652,8 +652,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented non-public class does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -677,8 +677,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented constructor does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -706,8 +706,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented method gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -736,8 +736,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented property gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -766,8 +766,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java undocumented inherited method gets reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -805,8 +805,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java documented inherited method does not get reported`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
@@ -842,8 +842,8 @@ class ReportUndocumentedTransformerTest : AbstractCoreTest() {
     @Test
     fun `java overridden function does not get reported when super is documented`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     reportUndocumented = true
                     sourceRoots = listOf("src/main/java")
                 }
diff --git a/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt b/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
index 5f8a7864..95fbb3c6 100644
--- a/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
+++ b/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
@@ -12,8 +12,8 @@ class DefaultPsiToDocumentableTranslatorTest : AbstractCoreTest() {
     @Test
     fun `method overriding two documented classes picks closest class documentation`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/java")
                 }
             }
@@ -57,8 +57,8 @@ class DefaultPsiToDocumentableTranslatorTest : AbstractCoreTest() {
     @Test
     fun `method overriding class and interface picks class documentation`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/java")
                 }
             }
@@ -102,8 +102,8 @@ class DefaultPsiToDocumentableTranslatorTest : AbstractCoreTest() {
     @Test
     fun `method overriding two classes picks closest documented class documentation`() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/main/java")
                 }
             }
@@ -153,4 +153,4 @@ class DefaultPsiToDocumentableTranslatorTest : AbstractCoreTest() {
             ?.body.orEmpty()
     }
 
-}
\ No newline at end of file
+}
diff --git a/plugins/base/src/test/kotlin/utils/ModelUtils.kt b/plugins/base/src/test/kotlin/utils/ModelUtils.kt
index 9697a843..87a9c802 100644
--- a/plugins/base/src/test/kotlin/utils/ModelUtils.kt
+++ b/plugins/base/src/test/kotlin/utils/ModelUtils.kt
@@ -16,8 +16,8 @@ abstract class AbstractModelTest(val path: String? = null, val pkg: String) : Mo
         block: DModule.() -> Unit
     ) {
         val testConfiguration = configuration ?: dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                     analysisPlatform = platform
                 }
diff --git a/plugins/gfm/src/main/kotlin/GfmPlugin.kt b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
index b955d403..287ef74f 100644
--- a/plugins/gfm/src/main/kotlin/GfmPlugin.kt
+++ b/plugins/gfm/src/main/kotlin/GfmPlugin.kt
@@ -140,7 +140,7 @@ open class CommonmarkRenderer(
                     platforms.joinToString(
                         prefix = " [",
                         postfix = "] $text "
-                    ) { "${it.moduleName}/${it.sourceSetID}" })
+                    ) { "${it.moduleDisplayName}/${it.sourceSetID}" })
                 buildNewLine()
             }
         }
@@ -157,7 +157,7 @@ open class CommonmarkRenderer(
     ) {
         if(node.dci.kind == ContentKind.Sample || node.dci.kind == ContentKind.Parameters){
             node.sourceSets.forEach {sourcesetData ->
-                append("${sourcesetData.moduleName}/${sourcesetData.sourceSetID}")
+                append("${sourcesetData.moduleDisplayName}/${sourcesetData.sourceSetID}")
                 buildNewLine()
                 buildTable(node.copy(children = node.children.filter { it.sourceSets.contains(sourcesetData) }, dci = node.dci.copy(kind = ContentKind.Main)), pageContext, sourceSetRestriction)
                 buildNewLine()
@@ -286,4 +286,4 @@ class MarkdownLocationProvider(
     dokkaContext
 ) {
     override val extension = ".md"
-}
\ No newline at end of file
+}
diff --git a/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt
index 138208ae..4fa65c58 100644
--- a/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt
+++ b/plugins/javadoc/src/test/kotlin/javadoc/AbstractJavadocTemplateMapTest.kt
@@ -15,8 +15,8 @@ import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 internal abstract class AbstractJavadocTemplateMapTest : AbstractCoreTest() {
     protected var config: DokkaConfigurationImpl = dokkaConfiguration {
         format = "javadoc"
-        passes {
-            pass {
+        sourceSets {
+            sourceSet {
                 sourceRoots = listOf("src")
                 analysisPlatform = "jvm"
             }
@@ -62,7 +62,6 @@ internal abstract class AbstractJavadocTemplateMapTest : AbstractCoreTest() {
     ) {
         testInline(query, configuration) {
             renderingStage = { rootPageNode, dokkaContext ->
-                // TODO NOW: Clarify preprocessors!
                 val transformedRootPageNode = preprocessors.fold(rootPageNode) { acc, pageTransformer ->
                     pageTransformer(acc)
                 }
diff --git a/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
index 905cb61b..31a33ad5 100644
--- a/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
+++ b/plugins/javadoc/src/test/kotlin/javadoc/JavadocTest.kt
@@ -10,8 +10,8 @@ class JavadocTest : AbstractCoreTest() {
     fun test() {
         val config = dokkaConfiguration {
             format = "javadoc"
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("jvmSrc/")
                     analysisPlatform = "jvm"
                 }
diff --git a/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt b/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt
index cbaa3dd6..a47f0142 100644
--- a/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt
+++ b/plugins/javadoc/src/test/kotlin/javadoc/location/JavadocLocationTest.kt
@@ -23,8 +23,8 @@ class JavadocTest : AbstractCoreTest() {
 
         val config = dokkaConfiguration {
             format = "javadoc"
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("jvmSrc/")
                     externalDocumentationLinks = listOf(
                         externalLink("https://docs.oracle.com/javase/8/docs/api/"),
@@ -60,4 +60,4 @@ class JavadocTest : AbstractCoreTest() {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt b/plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt
index db87051b..96446201 100644
--- a/plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt
+++ b/plugins/kotlin-as-java/src/test/kotlin/KotlinAsJavaPluginTest.kt
@@ -3,7 +3,6 @@ package kotlinAsJavaPlugin
 import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.testApi.testRunner.AbstractCoreTest
 import org.jetbrains.kotlin.utils.addToStdlib.cast
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.junit.jupiter.api.Test
 
 class KotlinAsJavaPluginTest : AbstractCoreTest() {
@@ -11,8 +10,8 @@ class KotlinAsJavaPluginTest : AbstractCoreTest() {
     @Test
     fun topLevelTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -49,8 +48,8 @@ class KotlinAsJavaPluginTest : AbstractCoreTest() {
     @Test
     fun topLevelWithClassTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
@@ -90,8 +89,8 @@ class KotlinAsJavaPluginTest : AbstractCoreTest() {
     @Test
     fun kotlinAndJavaTest() {
         val configuration = dokkaConfiguration {
-            passes {
-                pass {
+            sourceSets {
+                sourceSet {
                     sourceRoots = listOf("src/")
                 }
             }
diff --git a/runners/ant/build.gradle b/runners/ant/build.gradle
deleted file mode 100644
index 216420c6..00000000
--- a/runners/ant/build.gradle
+++ /dev/null
@@ -1,18 +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"
-    }
-}
-
-dependencies {
-    compile project(":core")
-    compileOnly group: 'org.apache.ant', name: 'ant', version: ant_version
-}
-
diff --git a/runners/ant/src/main/kotlin/ant/dokka.kt b/runners/ant/src/main/kotlin/ant/dokka.kt
deleted file mode 100644
index d275ed82..00000000
--- a/runners/ant/src/main/kotlin/ant/dokka.kt
+++ /dev/null
@@ -1,210 +0,0 @@
-package org.jetbrains.dokka.ant
-
-import org.apache.tools.ant.BuildException
-import org.apache.tools.ant.Project
-import org.apache.tools.ant.Task
-import org.apache.tools.ant.types.Path
-import org.apache.tools.ant.types.Reference
-import org.jetbrains.dokka.*
-import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jetbrains.dokka.utilities.DokkaLogger
-import java.io.File
-
-class AntLogger(val task: Task): DokkaLogger {
-    override var warningsCount: Int = 0
-    override var errorsCount: Int = 0
-    override fun debug(message: String) = task.log(message, Project.MSG_DEBUG)
-    override fun info(message: String) = task.log(message, Project.MSG_VERBOSE)
-    override fun progress(message: String) = task.log(message, Project.MSG_INFO)
-    override fun warn(message: String) = task.log(message, Project.MSG_WARN).also { warningsCount++ }
-    override fun error(message: String) = task.log(message, Project.MSG_ERR).also { errorsCount++ }
-    override fun report() {
-        if (warningsCount > 0 || errorsCount > 0) {
-            task.log("Generation completed with $warningsCount warning" +
-                    (if(warningsCount == 1) "" else "s") +
-                    " and $errorsCount error" +
-                    if(errorsCount == 1) "" else "s"
-            )
-        } else {
-            task.log("generation completed successfully")
-        }
-    }
-}
-
-class AntSourceLinkDefinition(var path: String? = null, var url: String? = null, var lineSuffix: String? = null)
-
-class AntSourceRoot(var path: String? = null) {
-    fun toSourceRoot(): SourceRootImpl? = path?.let { path ->
-        SourceRootImpl(path)
-    }
-}
-
-class TextProperty(var value: String = "")
-
-class AntPassConfig(task: Task) : DokkaConfiguration.PassConfiguration {
-    override var moduleName: String = ""
-    override val classpath: List<String>
-        get() = buildClassPath.list().toList()
-
-    override val sourceRoots: List<DokkaConfiguration.SourceRoot>
-        get() = sourcePath.list().map { SourceRootImpl(it) } + antSourceRoots.mapNotNull { it.toSourceRoot() }
-
-    override val samples: List<String>
-        get() = samplesPath.list().toList()
-    override val includes: List<String>
-        get() = includesPath.list().toList()
-    override var includeNonPublic: Boolean = false
-    override var includeRootPackage: Boolean = true
-    override var reportUndocumented: Boolean = false
-    override var skipEmptyPackages: Boolean = true
-    override var skipDeprecated: Boolean = false
-    override var jdkVersion: Int = 8
-    override val sourceLinks: List<DokkaConfiguration.SourceLinkDefinition>
-        get() = antSourceLinkDefinition.map {
-            val path = it.path!!
-            val url = it.url!!
-            SourceLinkDefinitionImpl(File(path).canonicalFile.absolutePath, url, it.lineSuffix)
-        }
-    override val perPackageOptions: MutableList<DokkaConfiguration.PackageOptions> = mutableListOf()
-    override val externalDocumentationLinks: List<ExternalDocumentationLink>
-        get() = buildExternalLinksBuilders.map { it.build() } + defaultExternalDocumentationLinks
-
-    override var languageVersion: String? = null
-    override var apiVersion: String? = null
-    override var noStdlibLink: Boolean = false
-    override var noJdkLink: Boolean = false
-    override var suppressedFiles: MutableList<String> = mutableListOf()
-    override var collectInheritedExtensionsFromLibraries: Boolean = false
-    override var analysisPlatform: Platform = Platform.DEFAULT
-    override var targets: List<String> = listOf()
-        get() = buildTargets.filter { it.value != "" }
-            .map { it.value }
-
-    override var sinceKotlin: String? = null
-
-    private val samplesPath: Path by lazy { Path(task.project) }
-    private val includesPath: Path by lazy { Path(task.project) }
-    private val buildClassPath: Path by lazy { Path(task.project) }
-    val sourcePath: Path by lazy { Path(task.project) }
-    val antSourceRoots: MutableList<AntSourceRoot> = mutableListOf()
-
-    private val buildTargets: MutableList<TextProperty> = mutableListOf()
-    private val buildExternalLinksBuilders: MutableList<ExternalDocumentationLink.Builder> = mutableListOf()
-    val antSourceLinkDefinition: MutableList<AntSourceLinkDefinition> = mutableListOf()
-
-    private val defaultExternalDocumentationLinks: List<DokkaConfiguration.ExternalDocumentationLink>
-        get() {
-            val links = mutableListOf<DokkaConfiguration.ExternalDocumentationLink>()
-            if (!noJdkLink)
-                links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://docs.oracle.com/javase/$jdkVersion/docs/api/").build()
-
-            if (!noStdlibLink)
-                links += DokkaConfiguration.ExternalDocumentationLink.Builder("https://kotlinlang.org/api/latest/jvm/stdlib/").build()
-            return links
-        }
-
-
-    fun setSamples(ref: Path) {
-        samplesPath.append(ref)
-    }
-
-    fun setSamplesRef(ref: Reference) {
-        samplesPath.createPath().refid = ref
-    }
-
-    fun setInclude(ref: Path) {
-        includesPath.append(ref)
-    }
-
-    fun setClasspath(classpath: Path) {
-        buildClassPath.append(classpath)
-    }
-
-    fun createPackageOptions(): AntPackageOptions = AntPackageOptions().apply { perPackageOptions.add(this) }
-
-    fun createSourceRoot(): AntSourceRoot = AntSourceRoot().apply {  antSourceRoots.add(this) }
-
-    fun createTarget(): TextProperty = TextProperty().apply {
-            buildTargets.add(this)
-    }
-
-    fun setClasspathRef(ref: Reference) {
-        buildClassPath.createPath().refid = ref
-    }
-
-    fun setSrc(src: Path) {
-        sourcePath.append(src)
-    }
-
-    fun setSrcRef(ref: Reference) {
-        sourcePath.createPath().refid = ref
-    }
-
-    fun createSourceLink(): AntSourceLinkDefinition {
-        val def = AntSourceLinkDefinition()
-        antSourceLinkDefinition.add(def)
-        return def
-    }
-
-    fun createExternalDocumentationLink() =
-        ExternalDocumentationLink.Builder().apply { buildExternalLinksBuilders.add(this) }
-
-}
-
-class AntPackageOptions(
-        override var prefix: String = "",
-        override var includeNonPublic: Boolean = false,
-        override var reportUndocumented: Boolean = true,
-        override var skipDeprecated: Boolean = false,
-        override var suppress: Boolean = false) : DokkaConfiguration.PackageOptions
-
-class DokkaAntTask: Task(), DokkaConfiguration {
-
-    override var format: String = "html"
-    override var generateIndexPages: Boolean = false
-    override var outputDir: String = ""
-    override var impliedPlatforms: List<String> = listOf()
-        get() = buildImpliedPlatforms.map { it.value }.toList()
-    private val buildImpliedPlatforms: MutableList<TextProperty> = mutableListOf()
-
-    override var cacheRoot: String? = null
-    override val passesConfigurations: MutableList<AntPassConfig> = mutableListOf()
-    override var pluginsClasspath: List<File> = mutableListOf()
-
-    fun createPassConfig() = AntPassConfig(this).apply { passesConfigurations.add(this) }
-    fun createImpliedPlatform(): TextProperty = TextProperty().apply { buildImpliedPlatforms.add(this) }
-
-
-    override fun execute() {
-        for (passConfig in passesConfigurations) {
-            if (passConfig.sourcePath.list().isEmpty() && passConfig.antSourceRoots.isEmpty()) {
-                throw BuildException("At least one source path needs to be specified")
-            }
-
-            if (passConfig.moduleName == "") {
-                throw BuildException("Module name needs to be specified and not empty")
-            }
-
-            for (sourceLink in passConfig.antSourceLinkDefinition) {
-                if (sourceLink.path == null) {
-                    throw BuildException("'path' attribute of a <sourceLink> element is required")
-                }
-                if (sourceLink.path!!.contains("\\")) {
-                    throw BuildException("'dir' attribute of a <sourceLink> - incorrect value, only Unix based path allowed")
-                }
-
-                if (sourceLink.url == null) {
-                    throw BuildException("'url' attribute of a <sourceLink> element is required")
-                }
-            }
-        }
-
-        if (outputDir == "") {
-            throw BuildException("Output directory needs to be specified and not empty")
-        }
-
-        val generator = DokkaGenerator(this, AntLogger(this))
-        generator.generate()
-    }
-}
\ No newline at end of file
diff --git a/runners/ant/src/main/resources/dokka-antlib.xml b/runners/ant/src/main/resources/dokka-antlib.xml
deleted file mode 100644
index 9c3373d5..00000000
--- a/runners/ant/src/main/resources/dokka-antlib.xml
+++ /dev/null
@@ -1,3 +0,0 @@
-<antlib>
-    <taskdef name="dokka" classname="org.jetbrains.dokka.ant.DokkaAntTask"/>
-</antlib>
diff --git a/runners/cli/build.gradle.kts b/runners/cli/build.gradle.kts
index 8c4955ca..bc09f2cd 100644
--- a/runners/cli/build.gradle.kts
+++ b/runners/cli/build.gradle.kts
@@ -10,7 +10,6 @@ repositories {
 
 dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-cli-jvm:0.2.1")
-    implementation("com.google.code.gson:gson:2.8.5")
     implementation(project(":core"))
     implementation(kotlin("stdlib"))
 }
@@ -36,4 +35,4 @@ publishing {
     }
 }
 
-configureBintrayPublication("dokkaCli")
\ No newline at end of file
+configureBintrayPublication("dokkaCli")
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/cli/main.kt
index b0fb45b2..5e5cd6b2 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/cli/main.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka
 
-import com.google.gson.Gson
 import kotlinx.cli.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink
 import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet.*
@@ -34,7 +33,7 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
     override val sourceSets by parser.option(
         ArgTypeArgument,
         description = "Single dokka source set",
-        fullName = "pass"
+        fullName = "sourceSet"
     ).multiple()
 
     override val pluginsConfiguration by parser.option(
@@ -60,7 +59,7 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
 
     val globalPackageOptions by parser.option(
         ArgType.String,
-        description = "List of package passConfiguration in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
+        description = "List of package source sets in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
     ).delimiter(";")
 
     val globalLinks by parser.option(
@@ -73,9 +72,9 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
         description = "Mapping between a source directory and a Web site for browsing the code (allows many paths separated by the semicolon `;`)"
     ).delimiter(";")
 
-    val helpPass by parser.option(
-        ArgTypeHelpPass,
-        description = "Prints help for single -pass"
+    val helpSourceSet by parser.option(
+        ArgTypeHelpSourceSet,
+        description = "Prints help for single -sourceSet"
     )
 
     override val modules: List<DokkaConfiguration.DokkaModuleDescription> = emptyList()
@@ -94,8 +93,8 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
 
         globalSrcLink.forEach {
             if (it.isNotEmpty() && it.contains("="))
-                sourceSets.all { pass ->
-                    pass.sourceLinks.cast<MutableList<SourceLinkDefinitionImpl>>()
+                sourceSets.all { sourceSet ->
+                    sourceSet.sourceLinks.cast<MutableList<SourceLinkDefinitionImpl>>()
                         .add(SourceLinkDefinitionImpl.parseSourceLinkDefinition(it))
                 }
             else {
@@ -112,9 +111,9 @@ class GlobalArguments(args: Array<String>) : DokkaConfiguration {
     }
 }
 
-fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
+private fun parseSourceSet(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
 
-    val parser = ArgParser("passConfiguration", prefixStyle = ArgParser.OptionPrefixStyle.JVM)
+    val parser = ArgParser("sourceSet", prefixStyle = ArgParser.OptionPrefixStyle.JVM)
 
     val moduleName by parser.option(
         ArgType.String,
@@ -122,16 +121,21 @@ fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
         fullName = "module"
     ).required()
 
-    val displayName by parser.option(
+    val moduleDisplayName by parser.option(
         ArgType.String,
-        description = "Name of the source set"
-    ).default("JVM")
+        description = "Name of the documentation module"
+    )
 
-    val sourceSetID by parser.option(
+    val name by parser.option(
         ArgType.String,
-        description = "ID of the source set"
+        description = "Name of the source set"
     ).default("main")
 
+    val displayName by parser.option(
+        ArgType.String,
+        description = "Displayed name of the source set"
+    ).default("JVM")
+
     val classpath by parser.option(
         ArgType.String,
         description = "Classpath for symbol resolution (allows many paths separated by the semicolon `;`)"
@@ -213,7 +217,7 @@ fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
 
     val perPackageOptions by parser.option(
         ArgType.String,
-        description = "List of package passConfiguration in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
+        description = "List of package source set configuration in format \"prefix,-deprecated,-privateApi,+warnUndocumented,+suppress;...\" "
     ).delimiter(";")
 
     val externalDocumentationLinks by parser.option(
@@ -230,12 +234,14 @@ fun passArguments(args: Array<String>): DokkaConfiguration.DokkaSourceSet {
     parser.parse(args)
 
     return object : DokkaConfiguration.DokkaSourceSet {
-        override val moduleName = moduleName
+        override val moduleDisplayName = moduleDisplayName ?: moduleName
         override val displayName = displayName
-        override val sourceSetID = sourceSetID
+        override val sourceSetID = DokkaSourceSetID(moduleName, name)
         override val classpath = classpath
         override val sourceRoots = sourceRoots.map { SourceRootImpl(it.toAbsolutePath()) }
-        override val dependentSourceSets: List<String> = dependentSourceSets
+        override val dependentSourceSets: Set<DokkaSourceSetID> = dependentSourceSets
+            .map { dependentSourceSetName -> DokkaSourceSetID(moduleName, dependentSourceSetName)  }
+            .toSet()
         override val samples = samples.map { it.toAbsolutePath() }
         override val includes = includes.map { it.toAbsolutePath() }
         override val includeNonPublic = includeNonPublic
@@ -294,15 +300,15 @@ object ArgTypeSourceLinkDefinition : ArgType<DokkaConfiguration.SourceLinkDefini
 
 object ArgTypeArgument : ArgType<DokkaConfiguration.DokkaSourceSet>(true) {
     override fun convert(value: kotlin.String, name: kotlin.String): DokkaConfiguration.DokkaSourceSet =
-        passArguments(value.split(" ").filter { it.isNotBlank() }.toTypedArray())
+        parseSourceSet(value.split(" ").filter { it.isNotBlank() }.toTypedArray())
 
     override val description: kotlin.String
         get() = ""
 }
 
 // Workaround for printing nested parsers help
-object ArgTypeHelpPass : ArgType<Any>(false) {
-    override fun convert(value: kotlin.String, name: kotlin.String): Any = Any().also { passArguments(arrayOf("-h")) }
+object ArgTypeHelpSourceSet : ArgType<Any>(false) {
+    override fun convert(value: kotlin.String, name: kotlin.String): Any = Any().also { parseSourceSet(arrayOf("-h")) }
 
     override val description: kotlin.String
         get() = ""
@@ -345,11 +351,10 @@ fun parseLinks(links: List<String>): List<ExternalDocumentationLink> {
 fun main(args: Array<String>) {
     val globalArguments = GlobalArguments(args)
     val configuration = if (globalArguments.json != null)
-        Gson().fromJson(
-            Paths.get(globalArguments.json).toFile().readText(),
-            DokkaConfigurationImpl::class.java
+        DokkaConfigurationImpl(
+            Paths.get(checkNotNull(globalArguments.json)).toFile().readText()
         )
     else
         globalArguments
     DokkaGenerator(configuration, DokkaConsoleLogger).generate()
-}
\ No newline at end of file
+}
diff --git a/runners/gradle-plugin/build.gradle.kts b/runners/gradle-plugin/build.gradle.kts
index 71d7e72f..2c25a707 100644
--- a/runners/gradle-plugin/build.gradle.kts
+++ b/runners/gradle-plugin/build.gradle.kts
@@ -19,6 +19,8 @@ dependencies {
     compileOnly(gradleKotlinDsl())
     testImplementation(gradleApi())
     testImplementation(kotlin("test-junit"))
+    testImplementation("org.jetbrains.kotlin:kotlin-gradle-plugin")
+
     constraints {
         val kotlin_version: String by project
         compileOnly("org.jetbrains.kotlin:kotlin-reflect:${kotlin_version}") {
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
index 3bd0b6ab..c9693467 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/ConfigurationExtractor.kt
@@ -169,4 +169,4 @@ class ConfigurationExtractor(private val project: Project) {
         val dependentSourceSets: List<String>,
         val platform: String
     ) : Serializable
-}
\ No newline at end of file
+}
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
index ead0f90a..823206e3 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaCollectorTask.kt
@@ -19,7 +19,7 @@ open class DokkaCollectorTask : DefaultTask() {
 
     @TaskAction
     fun collect() {
-        val passesConfigurations = getProjects(project).filter { it.name in modules }.flatMap {
+        val sourceSets = getProjects(project).filter { it.name in modules }.flatMap {
             val tasks = try {
                 it.tasks.withType(DokkaTask::class.java)
             } catch (e: UnknownTaskException) {
@@ -30,11 +30,11 @@ open class DokkaCollectorTask : DefaultTask() {
 
         val initial = GradleDokkaConfigurationImpl().apply {
             outputDir = outputDirectory
-            cacheRoot = passesConfigurations.first().cacheRoot
-            format = passesConfigurations.first().format
+            cacheRoot = sourceSets.first().cacheRoot
+            format = sourceSets.first().format
         }
 
-        configuration = passesConfigurations.fold(initial) { acc, it: GradleDokkaConfigurationImpl ->
+        configuration = sourceSets.fold(initial) { acc, it: GradleDokkaConfigurationImpl ->
             if(acc.format != it.format || acc.cacheRoot != it.cacheRoot)
                 throw IllegalStateException("Dokka task configurations differ on core arguments (format, cacheRoot)")
             acc.sourceSets = acc.sourceSets + it.sourceSets
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaSourceSetIDFactory.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaSourceSetIDFactory.kt
new file mode 100644
index 00000000..3fadb4fd
--- /dev/null
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/DokkaSourceSetIDFactory.kt
@@ -0,0 +1,10 @@
+@file:Suppress("FunctionName")
+
+package org.jetbrains.dokka.gradle
+
+import org.gradle.api.Project
+import org.jetbrains.dokka.DokkaSourceSetID
+
+internal fun DokkaSourceSetID(project: Project, sourceSetName: String): DokkaSourceSetID {
+    return DokkaSourceSetID(moduleName = project.path, sourceSetName = sourceSetName)
+}
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 e27357c9..aac7e2a0 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
@@ -7,11 +7,9 @@ import org.gradle.api.file.FileCollection
 import org.gradle.api.internal.plugins.DslObject
 import org.gradle.api.plugins.JavaBasePlugin
 import org.gradle.api.tasks.*
-import org.jetbrains.dokka.DokkaBootstrap
+import org.jetbrains.dokka.*
 import org.jetbrains.dokka.DokkaConfiguration.ExternalDocumentationLink.Builder
 import org.jetbrains.dokka.DokkaConfiguration.SourceRoot
-import org.jetbrains.dokka.DokkaException
-import org.jetbrains.dokka.Platform
 import org.jetbrains.dokka.ReflectDsl
 import org.jetbrains.dokka.ReflectDsl.isNotInstance
 import org.jetbrains.dokka.gradle.ConfigurationExtractor.PlatformData
@@ -183,10 +181,7 @@ open class DokkaTask : DefaultTask(), Configurable {
         val defaultModulesConfiguration = configuredDokkaSourceSets
             .map { configureDefault(it, globalConfig) }.takeIf { it.isNotEmpty() }
             ?: listOf(
-                configureDefault(
-                    configureDokkaSourceSet(GradleDokkaSourceSet("main")),
-                    null
-                )
+                configureDefault(configureDokkaSourceSet(GradleDokkaSourceSet("main", project)), null)
             ).takeIf { project.isNotMultiplatformProject() } ?: emptyList()
 
         if (defaultModulesConfiguration.isEmpty()) {
@@ -288,28 +283,25 @@ open class DokkaTask : DefaultTask(), Configurable {
     protected fun mergeUserConfigurationAndPlatformData(
         userConfig: GradleDokkaSourceSet,
         autoConfig: PlatformData
-    ) =
-        userConfig.copy().apply {
-            sourceRoots.addAll(userConfig.sourceRoots.union(autoConfig.sourceRoots.toSourceRoots()).distinct())
-            dependentSourceSets.addAll(userConfig.dependentSourceSets.union(autoConfig.dependentSourceSets).distinct())
-            classpath = userConfig.classpath.union(autoConfig.classpath.map { it.absolutePath }).distinct()
-            if (userConfig.platform == null && autoConfig.platform != "")
-                platform = autoConfig.platform
-        }
+    ) = userConfig.copy().apply {
+        sourceRoots.addAll(userConfig.sourceRoots.union(autoConfig.sourceRoots.toSourceRoots()).distinct())
+        dependentSourceSets.addAll(userConfig.dependentSourceSets)
+        dependentSourceSets.addAll(autoConfig.dependentSourceSets.map { DokkaSourceSetID(project, it) })
+        classpath = userConfig.classpath.union(autoConfig.classpath.map { it.absolutePath }).distinct()
+        if (userConfig.platform == null && autoConfig.platform != "")
+            platform = autoConfig.platform
+    }
 
     protected fun configureDefault(
         config: GradleDokkaSourceSet,
         globalConfig: GradleDokkaSourceSet?
     ): GradleDokkaSourceSet {
-        if (config.moduleName.isBlank()) {
-            config.moduleName = project.name
+        if (config.moduleDisplayName.isBlank()) {
+            config.moduleDisplayName = project.name
         }
-        if (config.sourceSetID.isBlank()) {
-            config.sourceSetID = config.moduleName + "/" + config.name
-        }
-        config.dependentSourceSets = config.dependentSourceSets.map { config.moduleName + "/" + it }.toMutableList()
+
         if (config.displayName.isBlank()) {
-            config.displayName = config.sourceSetID.substringBeforeLast("Main", config.platform.toString())
+            config.displayName = config.name.substringBeforeLast("Main", config.platform.toString())
         }
         config.classpath =
             (config.classpath as List<Any>).map { it.toString() }.distinct() // Workaround for Groovy's GStringImpl
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
index a28416d6..7b2d05a6 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/configurationImplementations.kt
@@ -1,13 +1,19 @@
+@file:Suppress("FunctionName")
+
 package org.jetbrains.dokka.gradle
 
+import com.android.build.gradle.api.AndroidSourceSet
 import groovy.lang.Closure
 import org.gradle.api.Action
+import org.gradle.api.Project
 import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.Optional
 import org.gradle.util.ConfigureUtil
 import org.jetbrains.dokka.DokkaConfiguration
 import org.jetbrains.dokka.DokkaConfiguration.*
 import org.jetbrains.dokka.DokkaDefaults
+import org.jetbrains.dokka.DokkaSourceSetID
 import org.jetbrains.dokka.Platform
 import java.io.File
 import java.io.Serializable
@@ -15,6 +21,8 @@ import java.net.URL
 import java.util.concurrent.Callable
 import kotlin.reflect.KMutableProperty
 import kotlin.reflect.full.memberProperties
+import org.gradle.api.tasks.SourceSet as GradleSourceSet
+import org.jetbrains.kotlin.gradle.model.SourceSet as KotlinSourceSet
 
 class GradleSourceRootImpl : SourceRoot, Serializable {
     override var path: String = ""
@@ -25,64 +33,113 @@ class GradleSourceRootImpl : SourceRoot, Serializable {
     override fun toString(): String = path
 }
 
-open class GradleDokkaSourceSet(@Transient val name: String = "") : DokkaSourceSet {
+open class GradleDokkaSourceSet constructor(
+    @Transient val name: String,
+    @Transient internal val project: Project
+) : DokkaSourceSet {
+
     @Input
     @Optional
     override var classpath: List<String> = emptyList()
+
     @Input
-    override var moduleName: String = ""
+    override var moduleDisplayName: String = ""
+
     @Input
     override var displayName: String = ""
-    @Input
-    override var sourceSetID: String = ""
+
+    @get:Internal
+    override val sourceSetID: DokkaSourceSetID = DokkaSourceSetID(project, name)
+
     @Input
     override var sourceRoots: MutableList<SourceRoot> = mutableListOf()
+
     @Input
-    override var dependentSourceSets: MutableList<String> = mutableListOf()
+    override var dependentSourceSets: MutableSet<DokkaSourceSetID> = mutableSetOf()
+
     @Input
     override var samples: List<String> = emptyList()
+
     @Input
     override var includes: List<String> = emptyList()
+
     @Input
     override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
+
     @Input
     override var includeRootPackage: Boolean = DokkaDefaults.includeRootPackage
+
     @Input
     override var reportUndocumented: Boolean = DokkaDefaults.reportUndocumented
+
     @Input
     override var skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages
+
     @Input
     override var skipDeprecated: Boolean = DokkaDefaults.skipDeprecated
+
     @Input
     override var jdkVersion: Int = DokkaDefaults.jdkVersion
+
     @Input
     override var sourceLinks: MutableList<SourceLinkDefinition> = mutableListOf()
+
     @Input
     override var perPackageOptions: MutableList<PackageOptions> = mutableListOf()
+
     @Input
     override var externalDocumentationLinks: MutableList<ExternalDocumentationLink> = mutableListOf()
+
     @Input
     @Optional
     override var languageVersion: String? = null
+
     @Input
     @Optional
     override var apiVersion: String? = null
+
     @Input
     override var noStdlibLink: Boolean = DokkaDefaults.noStdlibLink
+
     @Input
     override var noJdkLink: Boolean = DokkaDefaults.noJdkLink
+
     @Input
     var noAndroidSdkLink: Boolean = false
+
     @Input
     override var suppressedFiles: List<String> = emptyList()
+
     @Input
     override var analysisPlatform: Platform = DokkaDefaults.analysisPlatform
+
     @Input
     @Optional
     var platform: String? = null
+
     @Transient
     var collectKotlinTasks: (() -> List<Any?>?)? = null
 
+    fun DokkaSourceSetID(sourceSetName: String): DokkaSourceSetID {
+        return DokkaSourceSetID(project, sourceSetName)
+    }
+
+    fun dependsOn(sourceSet: GradleSourceSet) {
+        dependsOn(DokkaSourceSetID(sourceSet.name))
+    }
+
+    fun dependsOn(sourceSet: DokkaSourceSet) {
+        dependsOn(sourceSet.sourceSetID)
+    }
+
+    fun dependsOn(sourceSetName: String) {
+        dependsOn(DokkaSourceSetID(sourceSetName))
+    }
+
+    fun dependsOn(sourceSetID: DokkaSourceSetID) {
+        dependentSourceSets.add(sourceSetID)
+    }
+
     fun kotlinTasks(taskSupplier: Callable<List<Any>>) {
         collectKotlinTasks = { taskSupplier.call() }
     }
@@ -136,6 +193,18 @@ open class GradleDokkaSourceSet(@Transient val name: String = "") : DokkaSourceS
     }
 }
 
+fun GradleDokkaSourceSet.dependsOn(sourceSet: KotlinSourceSet) {
+    dependsOn(DokkaSourceSetID(sourceSet.name))
+}
+
+fun GradleDokkaSourceSet.dependsOn(sourceSet: org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet) {
+    dependsOn(DokkaSourceSetID(sourceSet.name))
+}
+
+fun GradleDokkaSourceSet.dependsOn(sourceSet: AndroidSourceSet) {
+    dependsOn(DokkaSourceSetID(sourceSet.name))
+}
+
 class GradleSourceLinkDefinitionImpl : SourceLinkDefinition, Serializable {
     override var path: String = ""
     override var url: String = ""
@@ -174,16 +243,16 @@ class GradlePackageOptionsImpl : PackageOptions, Serializable {
 }
 
 internal fun GradleDokkaSourceSet.copy(): GradleDokkaSourceSet {
-    val newObj = GradleDokkaSourceSet(this.name)
+    val newObj = GradleDokkaSourceSet(this.name, this.project)
     this::class.memberProperties.forEach { field ->
         if (field is KMutableProperty<*>) {
-            val value = field.getter.call(this)
-            if (value is Collection<*>) {
-                field.setter.call(newObj, value.toMutableList())
-            } else {
-                field.setter.call(newObj, field.getter.call(this))
+            when (val value = field.getter.call(this)) {
+                is List<*> -> field.setter.call(newObj, value.toMutableList())
+                is Set<*> -> field.setter.call(newObj, value.toMutableSet())
+                else -> field.setter.call(newObj, field.getter.call(this))
             }
+
         }
     }
     return newObj
-}
\ 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 92d63a40..a92f5475 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
@@ -53,7 +53,9 @@ open class DokkaPlugin : Plugin<Project> {
             project.tasks.create(DOKKA_TASK_NAME, taskClass)
         }
         project.tasks.withType(taskClass) { task ->
-            task.dokkaSourceSets = project.container(GradleDokkaSourceSet::class.java)
+            task.dokkaSourceSets = project.container(GradleDokkaSourceSet::class.java) { name ->
+                GradleDokkaSourceSet(name, project)
+            }
             task.dokkaRuntime = runtimeConfiguration
             task.pluginsClasspathConfiguration = pluginsConfiguration
             task.outputDirectory = File(project.buildDir, DOKKA_TASK_NAME).absolutePath
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
index 0b80f4a2..da6daeea 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/KotlinDslDokkaTaskConfigurationTest.kt
@@ -1,6 +1,9 @@
 package org.jetbrains.dokka.gradle
 
+import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.testfixtures.ProjectBuilder
+import org.jetbrains.dokka.DokkaSourceSetID
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -16,4 +19,78 @@ class KotlinDslDokkaTaskConfigurationTest {
             assertEquals("test", dokkaTask.outputFormat)
         }
     }
+
+    @Test
+    fun `sourceSet dependsOn by String`() {
+        val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
+        project.dokka {
+            dokkaSourceSets.run {
+                val commonMain = create("commonMain")
+                val jvmMain = create("jvmMain") {
+                    it.dependsOn("commonMain")
+                }
+
+                assertEquals(
+                    0, commonMain.dependentSourceSets.size,
+                    "Expected no dependent source set in commonMain"
+                )
+
+                assertEquals(
+                    1, jvmMain.dependentSourceSets.size,
+                    "Expected only one dependent source set in jvmMain"
+                )
+
+                assertEquals(
+                    commonMain.sourceSetID, jvmMain.dependentSourceSets.single(),
+                    "Expected jvmMain to depend on commonMain"
+                )
+
+                assertEquals(
+                    DokkaSourceSetID(project.path, "commonMain"), commonMain.sourceSetID
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `sourceSet dependsOn by DokkaSourceSet`() {
+        val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+
+        project.dokka {
+            dokkaSourceSets.run {
+                val commonMain = create("commonMain")
+                val jvmMain = create("jvmMain") {
+                    it.dependsOn(commonMain)
+                }
+
+                assertEquals(
+                    commonMain.sourceSetID, jvmMain.dependentSourceSets.single()
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `sourceSet dependsOn by KotlinSourceSet`() {
+        val project = ProjectBuilder.builder().build()
+        project.plugins.apply("org.jetbrains.dokka")
+        project.plugins.apply("org.jetbrains.kotlin.jvm")
+
+        val kotlin = project.extensions.getByName("kotlin") as KotlinJvmProjectExtension
+
+        project.dokka {
+            dokkaSourceSets.run {
+                val special = create("special") {
+                    it.dependsOn(kotlin.sourceSets.getByName("main"))
+                }
+
+                assertEquals(
+                    DokkaSourceSetID(project, "main"), special.dependentSourceSets.single()
+                )
+            }
+        }
+    }
 }
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index 4c10568c..8160ab87 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -90,9 +90,6 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     @Parameter
     var sourceRoots: List<SourceRoot> = emptyList()
 
-    @Parameter
-    var dependentSourceSets: List<String> = emptyList()
-
     @Parameter
     var samples: List<String> = emptyList()
 
@@ -108,6 +105,9 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
     @Parameter(required = true, defaultValue = "\${project.artifactId}")
     var moduleName: String = ""
 
+    @Parameter
+    var moduleDisplayName: String = ""
+
     @Parameter(required = false, defaultValue = "false")
     var skip: Boolean = false
 
@@ -201,12 +201,12 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
         }
 
         val sourceSet = DokkaSourceSetImpl(
-            moduleName = moduleName,
+            moduleDisplayName = moduleDisplayName.takeIf(String::isNotBlank) ?: moduleName,
             displayName = displayName,
-            sourceSetID = sourceSetName,
+            sourceSetID = DokkaSourceSetID(moduleName, sourceSetName),
             classpath = classpath,
             sourceRoots = sourceDirectories.map { SourceRootImpl(it) },
-            dependentSourceSets = dependentSourceSets,
+            dependentSourceSets = emptySet(),
             samples = samples,
             includes = includes,
             includeNonPublic = includeNonPublic,
@@ -246,7 +246,7 @@ abstract class AbstractDokkaMojo : AbstractMojo() {
             offlineMode = offlineMode,
             cacheRoot = cacheRoot,
             sourceSets = listOf(sourceSet).also {
-                if (sourceSet.moduleName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
+                if (sourceSet.moduleDisplayName.isEmpty()) logger.warn("Not specified module name. It can result in unexpected behaviour while including documentation for module")
             },
             pluginsClasspath = getArtifactByAether("org.jetbrains.dokka", "dokka-base", dokkaVersion) +
                     dokkaPlugins.map { getArtifactByAether(it.groupId, it.artifactId, it.version) }.flatten(),
diff --git a/testApi/src/main/kotlin/testApi/context/MockContext.kt b/testApi/src/main/kotlin/testApi/context/MockContext.kt
index 07aedf28..97347695 100644
--- a/testApi/src/main/kotlin/testApi/context/MockContext.kt
+++ b/testApi/src/main/kotlin/testApi/context/MockContext.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.testApi.context
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.plugability.ExtensionPoint
@@ -45,4 +44,4 @@ class MockContext(
 private fun DokkaPlugin.injectContext(context: DokkaContext) {
     (DokkaPlugin::class.memberProperties.single { it.name == "context" } as KMutableProperty<*>)
         .setter.call(this, context)
-}
\ No newline at end of file
+}
diff --git a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
index ec2be689..d3127263 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
@@ -1,7 +1,6 @@
 package org.jetbrains.dokka.testApi.testRunner
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.DokkaGenerator
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
@@ -43,4 +42,4 @@ internal class DokkaTestGenerator(
 
         dokkaGenerator.reportAfterRendering(context)
     }
-}
\ No newline at end of file
+}
diff --git a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
index 057045a8..381fb2af 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -174,25 +174,26 @@ abstract class AbstractCoreTest {
             failOnWarning = failOnWarning
         )
 
-        fun passes(block: Passes.() -> Unit) {
-            sourceSets.addAll(Passes().apply(block))
+        fun sourceSets(block: SourceSetsBuilder.() -> Unit) {
+            sourceSets.addAll(SourceSetsBuilder().apply(block))
         }
     }
 
     @DokkaConfigurationDsl
-    protected class Passes : ArrayList<DokkaSourceSetImpl>() {
-        fun pass(block: DokkaSourceSetBuilder.() -> Unit) =
-            add(DokkaSourceSetBuilder().apply(block).build())
+    protected class SourceSetsBuilder : ArrayList<DokkaSourceSetImpl>() {
+        fun sourceSet(block: DokkaSourceSetBuilder.() -> Unit): DokkaSourceSet =
+            DokkaSourceSetBuilder().apply(block).build().apply(::add)
     }
 
     @DokkaConfigurationDsl
     protected class DokkaSourceSetBuilder(
         var moduleName: String = "root",
-        var sourceSetID: String = "main",
+        var moduleDisplayName: String? = null,
+        var name: String = "main",
         var displayName: String = "JVM",
         var classpath: List<String> = emptyList(),
         var sourceRoots: List<String> = emptyList(),
-        var dependentSourceSets: List<String> = emptyList(),
+        var dependentSourceSets: Set<DokkaSourceSetID> = emptySet(),
         var samples: List<String> = emptyList(),
         var includes: List<String> = emptyList(),
         var includeNonPublic: Boolean = false,
@@ -212,9 +213,9 @@ abstract class AbstractCoreTest {
         var sourceLinks: List<SourceLinkDefinitionImpl> = emptyList()
     ) {
         fun build() = DokkaSourceSetImpl(
-            moduleName = moduleName,
+            moduleDisplayName = moduleDisplayName ?: moduleName,
             displayName = displayName,
-            sourceSetID = sourceSetID,
+            sourceSetID = DokkaSourceSetID(moduleName, name),
             classpath = classpath,
             sourceRoots = sourceRoots.map { SourceRootImpl(it) },
             dependentSourceSets = dependentSourceSets,
-- 
cgit 


From 9b7e163ae69272c7e56088d6f256d6b19f9a01d4 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Tue, 30 Jun 2020 21:05:16 +0200
Subject: Refactor Extension DSL and remove fallback mechanism

---
 core/src/main/kotlin/plugability/DokkaContext.kt |  33 ++++----
 core/src/main/kotlin/plugability/DokkaPlugin.kt  |  17 ++--
 core/src/main/kotlin/plugability/extensions.kt   | 101 ++++++++---------------
 plugins/base/src/main/kotlin/DokkaBase.kt        |  24 +++---
 4 files changed, 68 insertions(+), 107 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 15349ff0..12b1557b 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -46,7 +46,7 @@ inline fun <reified T : DokkaPlugin> DokkaContext.plugin(): T = plugin(T::class)
     ?: throw java.lang.IllegalStateException("Plugin ${T::class.qualifiedName} is not present in context.")
 
 interface DokkaContextConfiguration {
-    fun addExtensionDependencies(extension: Extension<*>)
+    fun addExtensionDependencies(extension: Extension<*, *, *>)
 }
 
 private class DokkaContextConfigurationImpl(
@@ -55,7 +55,7 @@ private class DokkaContextConfigurationImpl(
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
     private val pluginStubs = mutableMapOf<KClass<*>, DokkaPlugin>()
-    internal val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*>>>()
+    val extensions = mutableMapOf<ExtensionPoint<*>, MutableList<Extension<*, *, *>>>()
     val pointsUsed: MutableSet<ExtensionPoint<*>> = mutableSetOf()
     val pointsPopulated: MutableSet<ExtensionPoint<*>> = mutableSetOf()
     override val unusedPoints: Set<ExtensionPoint<*>>
@@ -67,14 +67,14 @@ private class DokkaContextConfigurationImpl(
         VISITED;
     }
 
-    internal val verticesWithState = mutableMapOf<Extension<*>, State>()
-    internal val adjacencyList: MutableMap<Extension<*>, MutableList<Extension<*>>> = mutableMapOf()
+    val verticesWithState = mutableMapOf<Extension<*, *, *>, State>()
+    val adjacencyList: MutableMap<Extension<*, *, *>, MutableList<Extension<*, *, *>>> = mutableMapOf()
 
     private fun topologicalSort() {
 
-        val result: MutableList<Extension<*>> = mutableListOf()
+        val result: MutableList<Extension<*, *, *>> = mutableListOf()
 
-        fun visit(n: Extension<*>) {
+        fun visit(n: Extension<*, *, *>) {
             val state = verticesWithState[n]
             if (state == State.VISITED)
                 return
@@ -107,14 +107,11 @@ private class DokkaContextConfigurationImpl(
         )
         pointsUsed += point
 
-        val extensions = extensions[point].orEmpty() as List<Extension<T>>
+        val extensions = extensions[point].orEmpty() as List<Extension<T, *, *>>
         return when (extensions.size) {
             0 -> throwBadArity("none was")
             1 -> extensions.single().action.get(this)
-            else -> {
-                val notFallbacks = extensions.filterNot { it.isFallback }
-                if (notFallbacks.size == 1) notFallbacks.single().action.get(this) else throwBadArity("many were")
-            }
+            else -> throwBadArity("many were")
         }
     }
 
@@ -132,13 +129,15 @@ private class DokkaContextConfigurationImpl(
         plugin.internalInstall(this, this.configuration)
     }
 
-    override fun addExtensionDependencies(extension: Extension<*>) {
-        val orderDsl = OrderDsl()
-        extension.ordering?.invoke(orderDsl)
+    override fun addExtensionDependencies(extension: Extension<*, *, *>) {
+        if (extension.ordering is OrderingKind.ByDsl) {
+            val orderDsl = OrderDsl()
+            extension.ordering.block.invoke(orderDsl)
 
-        verticesWithState += extension to State.UNVISITED
-        adjacencyList.getOrPut(extension, ::mutableListOf) += orderDsl.following.toList()
-        orderDsl.previous.forEach { adjacencyList.getOrPut(it, ::mutableListOf) += extension }
+            verticesWithState += extension to State.UNVISITED
+            adjacencyList.getOrPut(extension, ::mutableListOf) += orderDsl.following.toList()
+            orderDsl.previous.forEach { adjacencyList.getOrPut(it, ::mutableListOf) += extension }
+        }
     }
 
     fun logInitialisationInfo() {
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 7ead43b8..bf82daa7 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -7,8 +7,6 @@ import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
 import kotlin.reflect.full.createInstance
 
-private typealias ExtensionDelegate<T> = ReadOnlyProperty<DokkaPlugin, Extension<T>>
-
 abstract class DokkaPlugin {
     private val extensionDelegates = mutableListOf<KProperty<*>>()
 
@@ -25,15 +23,10 @@ abstract class DokkaPlugin {
             )
         }
 
-    protected fun <T : Any> extending(isFallback: Boolean = false, definition: ExtendingDSL.() -> Extension<T>) =
-        if (isFallback) {
-            ExtensionProvider { definition().markedAsFallback() }
-        } else {
-            ExtensionProvider(definition)
-        }
+    protected fun <T : Any> extending(definition: ExtendingDSL.() -> Extension<T, *, *>) = ExtensionProvider(definition)
 
     protected class ExtensionProvider<T : Any> internal constructor(
-        private val definition: ExtendingDSL.() -> Extension<T>
+        private val definition: ExtendingDSL.() -> Extension<T, *, *>
     ) {
         operator fun provideDelegate(thisRef: DokkaPlugin, property: KProperty<*>) = lazy {
             ExtendingDSL(
@@ -45,7 +38,7 @@ abstract class DokkaPlugin {
 
     internal fun internalInstall(ctx: DokkaContextConfiguration, configuration: DokkaConfiguration) {
         extensionDelegates.asSequence()
-            .filterIsInstance<KProperty1<DokkaPlugin, Extension<*>>>() // should be always true
+            .filterIsInstance<KProperty1<DokkaPlugin, Extension<*, *, *>>>() // should be always true
             .map { it.get(this) }
             .forEach { if (it.condition.invoke(configuration)) ctx.addExtensionDependencies(it) }
     }
@@ -76,8 +69,8 @@ fun throwIllegalQuery(): Nothing =
 inline fun <reified T : DokkaPlugin, reified R : ConfigurableBlock> configuration(context: DokkaContext): ReadOnlyProperty<Any?, R> {
     return object : ReadOnlyProperty<Any?, R> {
         override fun getValue(thisRef: Any?, property: KProperty<*>): R {
-            return context.configuration.pluginsConfiguration.get(T::class.qualifiedName
-                ?: throw AssertionError("Plugin must be named class")).let {
+            return context.configuration.pluginsConfiguration[T::class.qualifiedName
+                ?: throw AssertionError("Plugin must be named class")].let {
                     Gson().fromJson(it, R::class.java)
             }
         }
diff --git a/core/src/main/kotlin/plugability/extensions.kt b/core/src/main/kotlin/plugability/extensions.kt
index 20b60469..c6dd0b85 100644
--- a/core/src/main/kotlin/plugability/extensions.kt
+++ b/core/src/main/kotlin/plugability/extensions.kt
@@ -9,79 +9,43 @@ data class ExtensionPoint<T : Any> internal constructor(
     override fun toString() = "ExtensionPoint: $pluginClass/$pointName"
 }
 
-abstract class Extension<T : Any> internal constructor(
+sealed class OrderingKind {
+    object None : OrderingKind()
+    class ByDsl(val block: (OrderDsl.() -> Unit)) : OrderingKind()
+}
+
+sealed class OverrideKind {
+    object None : OverrideKind()
+    class Present(val overriden: Extension<*, *, *>) : OverrideKind()
+}
+
+class Extension<T : Any, Ordering : OrderingKind, Override : OverrideKind> internal constructor(
     internal val extensionPoint: ExtensionPoint<T>,
     internal val pluginClass: String,
     internal val extensionName: String,
     internal val action: LazyEvaluated<T>,
-    internal val ordering: (OrderDsl.() -> Unit)? = null,
-    internal val conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
-    internal val isFallback: Boolean
+    internal val ordering: Ordering,
+    internal val override: Override,
+    internal val conditions: List<DokkaConfiguration.() -> Boolean>
 ) {
     override fun toString() = "Extension: $pluginClass/$extensionName"
 
     override fun equals(other: Any?) =
-        if (other is Extension<*>) this.pluginClass == other.pluginClass && this.extensionName == other.extensionName
+        if (other is Extension<*, *, *>) this.pluginClass == other.pluginClass && this.extensionName == other.extensionName
         else false
 
     override fun hashCode() = listOf(pluginClass, extensionName).hashCode()
 
-    abstract fun addCondition(condition: (DokkaConfiguration.() -> Boolean)): Extension<T>
-
-    abstract fun markedAsFallback(): Extension<T>
-
-    open val condition: DokkaConfiguration.() -> Boolean
-        get() = { conditions.all { it(this) }}
+    val condition: DokkaConfiguration.() -> Boolean
+        get() = { conditions.all { it(this) } }
 }
 
-class ExtensionOrdered<T : Any> internal constructor(
+private fun <T : Any> Extension(
     extensionPoint: ExtensionPoint<T>,
     pluginClass: String,
     extensionName: String,
-    action: LazyEvaluated<T>,
-    ordering: (OrderDsl.() -> Unit),
-    conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
-    isFallback: Boolean = false
-) : Extension<T>(
-    extensionPoint,
-    pluginClass,
-    extensionName,
-    action,
-    ordering,
-    conditions,
-    isFallback
-) {
-    override fun addCondition(condition: DokkaConfiguration.() -> Boolean) =
-        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, conditions + condition)
-
-    override fun markedAsFallback() =
-        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, ordering!!, conditions, true)
-}
-
-class ExtensionUnordered<T : Any> internal constructor(
-    extensionPoint: ExtensionPoint<T>,
-    pluginClass: String,
-    extensionName: String,
-    action: LazyEvaluated<T>,
-    conditions: Array<DokkaConfiguration.() -> Boolean> = emptyArray(),
-    isFallback: Boolean = false
-) : Extension<T>(
-    extensionPoint,
-    pluginClass,
-    extensionName,
-    action,
-    null,
-    conditions,
-    isFallback
-) {
-    override fun addCondition(condition: DokkaConfiguration.() -> Boolean) =
-        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, conditions + condition)
-
-    override fun markedAsFallback() =
-        ExtensionUnordered(extensionPoint, pluginClass, extensionName, action, conditions, true)
-}
-
-internal data class Ordering(val previous: Set<Extension<*>>, val following: Set<Extension<*>>)
+    action: LazyEvaluated<T>
+) = Extension(extensionPoint, pluginClass, extensionName, action, OrderingKind.None, OverrideKind.None, emptyList())
 
 @DslMarker
 annotation class ExtensionsDsl
@@ -90,29 +54,34 @@ annotation class ExtensionsDsl
 class ExtendingDSL(private val pluginClass: String, private val extensionName: String) {
 
     infix fun <T : Any> ExtensionPoint<T>.with(action: T) =
-        ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromInstance(action))
+        Extension(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromInstance(action))
 
     infix fun <T : Any> ExtensionPoint<T>.providing(action: (DokkaContext) -> T) =
-        ExtensionUnordered(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromRecipe(action))
+        Extension(this, this@ExtendingDSL.pluginClass, extensionName, LazyEvaluated.fromRecipe(action))
 
-    infix fun <T : Any> ExtensionUnordered<T>.order(block: OrderDsl.() -> Unit) =
-        ExtensionOrdered(extensionPoint, pluginClass, extensionName, action, block)
+    infix fun <T : Any, Override : OverrideKind> Extension<T, OrderingKind.None, Override>.order(
+        block: OrderDsl.() -> Unit
+    ) = Extension(extensionPoint, pluginClass, extensionName, action, OrderingKind.ByDsl(block), override, conditions)
 
-    infix fun <T : Any> Extension<T>.applyIf(condition: DokkaConfiguration.() -> Boolean): Extension<T> =
-        this.addCondition(condition)
+    infix fun <T : Any, Override : OverrideKind, Ordering: OrderingKind> Extension<T, Ordering, Override>.applyIf(
+        condition: DokkaConfiguration.() -> Boolean
+    ) = Extension(extensionPoint, pluginClass, extensionName, action, ordering, override, conditions + condition)
 
+    infix fun <T : Any, Override : OverrideKind, Ordering: OrderingKind> Extension<T, Ordering, Override>.override(
+        overriden: Extension<T, *, *>
+    ) = Extension(extensionPoint, pluginClass, extensionName, action, ordering, OverrideKind.Present(overriden), conditions)
 }
 
 @ExtensionsDsl
 class OrderDsl {
-    internal val previous = mutableSetOf<Extension<*>>()
-    internal val following = mutableSetOf<Extension<*>>()
+    internal val previous = mutableSetOf<Extension<*, *, *>>()
+    internal val following = mutableSetOf<Extension<*, *, *>>()
 
-    fun after(vararg extensions: Extension<*>) {
+    fun after(vararg extensions: Extension<*, *, *>) {
         previous += extensions
     }
 
-    fun before(vararg extensions: Extension<*>) {
+    fun before(vararg extensions: Extension<*, *, *>) {
         following += extensions
     }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/DokkaBase.kt b/plugins/base/src/main/kotlin/DokkaBase.kt
index 0e535c86..8fed0afd 100644
--- a/plugins/base/src/main/kotlin/DokkaBase.kt
+++ b/plugins/base/src/main/kotlin/DokkaBase.kt
@@ -55,19 +55,19 @@ class DokkaBase : DokkaPlugin() {
         }
     }
 
-    val documentableMerger by extending(isFallback = true) {
+    val documentableMerger by extending {
         CoreExtensions.documentableMerger with DefaultDocumentableMerger
     }
 
-    val deprecatedDocumentableFilter by extending(isFallback = true) {
+    val deprecatedDocumentableFilter by extending {
         CoreExtensions.preMergeDocumentableTransformer providing ::DeprecatedDocumentableFilterTransformer
     }
 
-    val documentableVisbilityFilter by extending(isFallback = true) {
+    val documentableVisbilityFilter by extending {
         CoreExtensions.preMergeDocumentableTransformer providing ::DocumentableVisibilityFilterTransformer
     }
 
-    val emptyPackagesFilter by extending(isFallback = true) {
+    val emptyPackagesFilter by extending {
         CoreExtensions.preMergeDocumentableTransformer providing ::EmptyPackagesFilterTransformer order {
             after(deprecatedDocumentableFilter, documentableVisbilityFilter)
         }
@@ -77,13 +77,13 @@ class DokkaBase : DokkaPlugin() {
         CoreExtensions.documentableTransformer with ActualTypealiasAdder()
     }
 
-    val modulesAndPackagesDocumentation by extending(isFallback = true) {
+    val modulesAndPackagesDocumentation by extending {
         CoreExtensions.preMergeDocumentableTransformer providing { ctx ->
             ModuleAndPackageDocumentationTransformer(ctx, ctx.single(kotlinAnalysis))
         }
     }
 
-    val kotlinSignatureProvider by extending(isFallback = true) {
+    val kotlinSignatureProvider by extending {
         signatureProvider providing { ctx ->
             KotlinSignatureProvider(ctx.single(commentsToContentConverter), ctx.logger)
         }
@@ -106,7 +106,7 @@ class DokkaBase : DokkaPlugin() {
         CoreExtensions.documentableTransformer with ExtensionExtractorTransformer()
     }
 
-    val documentableToPageTranslator by extending(isFallback = true) {
+    val documentableToPageTranslator by extending {
         CoreExtensions.documentableToPageTranslator providing { ctx ->
             DefaultDocumentableToPageTranslator(
                 ctx.single(commentsToContentConverter),
@@ -116,7 +116,7 @@ class DokkaBase : DokkaPlugin() {
         }
     }
 
-    val docTagToContentConverter by extending(isFallback = true) {
+    val docTagToContentConverter by extending {
         commentsToContentConverter with DocTagToContentConverter
     }
 
@@ -138,11 +138,11 @@ class DokkaBase : DokkaPlugin() {
         CoreExtensions.renderer providing ::HtmlRenderer applyIf { format == "html" }
     }
 
-    val defaultKotlinAnalysis by extending(isFallback = true) {
+    val defaultKotlinAnalysis by extending {
         kotlinAnalysis providing { ctx -> KotlinAnalysis(ctx) }
     }
 
-    val locationProvider by extending(isFallback = true) {
+    val locationProvider by extending {
         locationProviderFactory providing ::DefaultLocationProviderFactory
     }
 
@@ -154,7 +154,7 @@ class DokkaBase : DokkaPlugin() {
         externalLocationProviderFactory with DokkaExternalLocationProviderFactory()
     }
 
-    val fileWriter by extending(isFallback = true) {
+    val fileWriter by extending {
         outputWriter providing ::FileWriter
     }
 
@@ -211,7 +211,7 @@ class DokkaBase : DokkaPlugin() {
         htmlPreprocessors providing ::SourcesetDependencyAppender order { after(rootCreator) }
     }
 
-    val allModulePageCreators by extending(isFallback = true) {
+    val allModulePageCreators by extending {
         CoreExtensions.allModulePageCreator providing {
             MultimodulePageCreator(it)
         }
-- 
cgit 


From 177ede83228515f03436a4ac0ce1ce573fc3d74b Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Wed, 1 Jul 2020 16:57:58 +0200
Subject: Add functionality to plugin overrides

---
 core/src/main/kotlin/DokkaGenerator.kt             |  5 +-
 core/src/main/kotlin/plugability/DokkaContext.kt   | 85 ++++++++++++++++------
 core/src/main/kotlin/plugability/DokkaPlugin.kt    |  2 +-
 .../testApi/testRunner/DokkaTestGenerator.kt       |  4 +-
 4 files changed, 70 insertions(+), 26 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index ee1adf0b..d694cc8c 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -10,6 +10,7 @@ import org.jetbrains.dokka.utilities.DokkaLogger
 
 /**
  * DokkaGenerator is the main entry point for generating documentation
+ *
  * [generate] method has been split into submethods for test reasons
  */
 class DokkaGenerator(
@@ -62,8 +63,8 @@ class DokkaGenerator(
     fun initializePlugins(
         configuration: DokkaConfiguration,
         logger: DokkaLogger,
-        pluginOverrides: List<DokkaPlugin> = emptyList()
-    ) = DokkaContext.create(configuration, logger, pluginOverrides)
+        additionalPlugins: List<DokkaPlugin> = emptyList()
+    ) = DokkaContext.create(configuration, logger, additionalPlugins)
 
     fun createDocumentationModels(
         context: DokkaContext
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 12b1557b..30566d15 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -37,7 +37,7 @@ interface DokkaContext {
                     .let { ServiceLoader.load(DokkaPlugin::class.java, it) }
                     .let { it + pluginOverrides }
                     .forEach { install(it) }
-                applyExtensions()
+                topologicallySortAndPrune()
             }.also { it.logInitialisationInfo() }
     }
 }
@@ -46,7 +46,7 @@ inline fun <reified T : DokkaPlugin> DokkaContext.plugin(): T = plugin(T::class)
     ?: throw java.lang.IllegalStateException("Plugin ${T::class.qualifiedName} is not present in context.")
 
 interface DokkaContextConfiguration {
-    fun addExtensionDependencies(extension: Extension<*, *, *>)
+    fun installExtension(extension: Extension<*, *, *>)
 }
 
 private class DokkaContextConfigurationImpl(
@@ -67,11 +67,26 @@ private class DokkaContextConfigurationImpl(
         VISITED;
     }
 
-    val verticesWithState = mutableMapOf<Extension<*, *, *>, State>()
-    val adjacencyList: MutableMap<Extension<*, *, *>, MutableList<Extension<*, *, *>>> = mutableMapOf()
+    private sealed class Suppression {
+        data class ByExtension(val extension: Extension<*, *, *>) : Suppression()
 
-    private fun topologicalSort() {
 
+        data class ByPlugin(val plugin: DokkaPlugin) : Suppression()
+    }
+
+    private val rawExtensions = mutableListOf<Extension<*, *, *>>()
+    private val rawAdjacencyList = mutableMapOf<Extension<*, *, *>, MutableList<Extension<*, *, *>>>()
+    private val suppressedExtensions = mutableMapOf<Extension<*, *, *>, MutableList<Suppression>>()
+
+    fun topologicallySortAndPrune() {
+        pointsPopulated.clear()
+        extensions.clear()
+
+        val overridesInfo = processOverrides()
+        val extensionsToSort = overridesInfo.keys
+        val adjacencyList = translateAdjacencyList(overridesInfo)
+
+        val verticesWithState = extensionsToSort.associateWithTo(mutableMapOf()) { State.UNVISITED }
         val result: MutableList<Extension<*, *, *>> = mutableListOf()
 
         fun visit(n: Extension<*, *, *>) {
@@ -86,14 +101,39 @@ private class DokkaContextConfigurationImpl(
             result += n
         }
 
-        for ((vertex, state) in verticesWithState) {
-            if (state == State.UNVISITED)
-                visit(vertex)
-        }
-        result.asReversed().forEach {
-            pointsPopulated += it.extensionPoint
-            extensions.getOrPut(it.extensionPoint, ::mutableListOf) += it
+        extensionsToSort.forEach(::visit)
+
+        val filteredResult = result.asReversed().filterNot { it in suppressedExtensions }
+
+        filteredResult.mapTo(pointsPopulated) { it.extensionPoint }
+        filteredResult.groupByTo(extensions) { it.extensionPoint }
+    }
+
+    private fun processOverrides(): Map<Extension<*, *, *>, Set<Extension<*, *, *>>> {
+        val buckets = rawExtensions.associateWithTo(mutableMapOf()) { setOf(it) }
+        suppressedExtensions.forEach { (extension, suppressions) ->
+            val mergedBucket = suppressions.filterIsInstance<Suppression.ByExtension>()
+                .map { it.extension }
+                .plus(extension)
+                .flatMap { buckets[it].orEmpty() }
+                .toSet()
+            mergedBucket.forEach { buckets[it] = mergedBucket }
         }
+        return buckets.values.distinct().associateBy(::findNotOverridden)
+    }
+
+    private fun findNotOverridden(bucket: Set<Extension<*, *, *>>): Extension<*, *, *> {
+        val filtered = bucket.filter { it !in suppressedExtensions }
+        return filtered.singleOrNull() ?: throw Error("Conflicting overrides: $filtered")
+    }
+
+    private fun translateAdjacencyList(
+        overridesInfo: Map<Extension<*, *, *>, Set<Extension<*, *, *>>>
+    ): Map<Extension<*, *, *>, List<Extension<*, *, *>>> {
+        val reverseOverrideInfo = overridesInfo.flatMap { (ext, set) -> set.map { it to ext } }.toMap()
+        return rawAdjacencyList.map { (ext, list) ->
+            reverseOverrideInfo.getValue(ext) to list.map { reverseOverrideInfo.getValue(it) }
+        }.toMap()
     }
 
     @Suppress("UNCHECKED_CAST")
@@ -129,14 +169,19 @@ private class DokkaContextConfigurationImpl(
         plugin.internalInstall(this, this.configuration)
     }
 
-    override fun addExtensionDependencies(extension: Extension<*, *, *>) {
+    override fun installExtension(extension: Extension<*, *, *>) {
+        rawExtensions += extension
+
         if (extension.ordering is OrderingKind.ByDsl) {
             val orderDsl = OrderDsl()
-            extension.ordering.block.invoke(orderDsl)
+            orderDsl.(extension.ordering.block)()
 
-            verticesWithState += extension to State.UNVISITED
-            adjacencyList.getOrPut(extension, ::mutableListOf) += orderDsl.following.toList()
-            orderDsl.previous.forEach { adjacencyList.getOrPut(it, ::mutableListOf) += extension }
+            rawAdjacencyList.listFor(extension) += orderDsl.following.toList()
+            orderDsl.previous.forEach { rawAdjacencyList.listFor(it) += extension }
+        }
+
+        if (extension.override is OverrideKind.Present) {
+            suppressedExtensions.listFor(extension.override.overriden) += Suppression.ByExtension(extension)
         }
     }
 
@@ -150,10 +195,6 @@ private class DokkaContextConfigurationImpl(
         logger.progress("Loaded: $loadedListForDebug")
 
     }
-
-    fun applyExtensions() {
-        topologicalSort()
-    }
 }
 
 private fun checkClasspath(classLoader: URLClassLoader) {
@@ -164,3 +205,5 @@ private fun checkClasspath(classLoader: URLClassLoader) {
         )
     }
 }
+
+private fun <K, V> MutableMap<K, MutableList<V>>.listFor(key: K) = getOrPut(key, ::mutableListOf)
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index bf82daa7..671cefad 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -40,7 +40,7 @@ abstract class DokkaPlugin {
         extensionDelegates.asSequence()
             .filterIsInstance<KProperty1<DokkaPlugin, Extension<*, *, *>>>() // should be always true
             .map { it.get(this) }
-            .forEach { if (it.condition.invoke(configuration)) ctx.addExtensionDependencies(it) }
+            .forEach { if (configuration.(it.condition)()) ctx.installExtension(it) }
     }
 }
 
diff --git a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
index d3127263..414919dc 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/DokkaTestGenerator.kt
@@ -9,14 +9,14 @@ internal class DokkaTestGenerator(
     private val configuration: DokkaConfiguration,
     private val logger: DokkaLogger,
     private val testMethods: TestMethods,
-    private val pluginOverrides: List<DokkaPlugin> = emptyList()
+    private val additionalPlugins: List<DokkaPlugin> = emptyList()
 ) {
 
     fun generate() = with(testMethods) {
         val dokkaGenerator = DokkaGenerator(configuration, logger)
 
         val context =
-            dokkaGenerator.initializePlugins(configuration, logger, pluginOverrides)
+            dokkaGenerator.initializePlugins(configuration, logger, additionalPlugins)
         pluginsSetupStage(context)
 
         val modulesFromPlatforms = dokkaGenerator.createDocumentationModels(context)
-- 
cgit 


From 145a63c9d39c1c59c4a5d6c81dabd078d64edd4b Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Wed, 1 Jul 2020 19:16:38 +0200
Subject: Probably fix the missing adjecent extension bug

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 30566d15..5c595c75 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -131,8 +131,8 @@ private class DokkaContextConfigurationImpl(
         overridesInfo: Map<Extension<*, *, *>, Set<Extension<*, *, *>>>
     ): Map<Extension<*, *, *>, List<Extension<*, *, *>>> {
         val reverseOverrideInfo = overridesInfo.flatMap { (ext, set) -> set.map { it to ext } }.toMap()
-        return rawAdjacencyList.map { (ext, list) ->
-            reverseOverrideInfo.getValue(ext) to list.map { reverseOverrideInfo.getValue(it) }
+        return rawAdjacencyList.mapNotNull { (ext, list) ->
+            reverseOverrideInfo[ext]?.to(list.mapNotNull { reverseOverrideInfo[it] })
         }.toMap()
     }
 
-- 
cgit 


From 1f73de1df8cce09ac4e760db34759ca70ee12b6d Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Wed, 1 Jul 2020 19:27:38 +0200
Subject: Add suppression capabilities for plugins

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 6 ++++++
 core/src/main/kotlin/plugability/DokkaPlugin.kt  | 4 ++++
 2 files changed, 10 insertions(+)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 5c595c75..e7028ccf 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -167,6 +167,12 @@ private class DokkaContextConfigurationImpl(
         plugins[plugin::class] = plugin
         plugin.context = this
         plugin.internalInstall(this, this.configuration)
+
+        if (plugin is WithUnsafeExtensionSuppression) {
+            plugin.extensionsSuppressed.forEach {
+                suppressedExtensions.listFor(it) += Suppression.ByPlugin(plugin)
+            }
+        }
     }
 
     override fun installExtension(extension: Extension<*, *, *>) {
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 671cefad..2c755a49 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -44,6 +44,10 @@ abstract class DokkaPlugin {
     }
 }
 
+interface WithUnsafeExtensionSuppression {
+    val extensionsSuppressed: List<Extension<*, *, *>>
+}
+
 interface Configurable {
     val pluginsConfiguration: Map<String, String>
 }
-- 
cgit 


From 0a73ca69049163d59185223f518a9fc22afccaab Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Wed, 1 Jul 2020 19:35:29 +0200
Subject: Add suppression reporting to log

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index e7028ccf..59090522 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -68,10 +68,13 @@ private class DokkaContextConfigurationImpl(
     }
 
     private sealed class Suppression {
-        data class ByExtension(val extension: Extension<*, *, *>) : Suppression()
-
+        data class ByExtension(val extension: Extension<*, *, *>) : Suppression() {
+            override fun toString() = extension.toString()
+        }
 
-        data class ByPlugin(val plugin: DokkaPlugin) : Suppression()
+        data class ByPlugin(val plugin: DokkaPlugin) : Suppression() {
+            override fun toString() = "Plugin ${plugin::class.qualifiedName}"
+        }
     }
 
     private val rawExtensions = mutableListOf<Extension<*, *, *>>()
@@ -197,9 +200,14 @@ private class DokkaContextConfigurationImpl(
         val loadedListForDebug = extensions.run { keys + values.flatten() }.toList()
             .joinToString(prefix = "[\n", separator = ",\n", postfix = "\n]") { "\t$it" }
 
+        val suppressedList = suppressedExtensions.asSequence()
+            .joinToString(prefix = "[\n", separator = ",\n", postfix = "\n]") {
+                "\t${it.key} by " + (it.value.singleOrNull() ?: it.value)
+            }
+
         logger.progress("Loaded plugins: $pluginNames")
         logger.progress("Loaded: $loadedListForDebug")
-
+        logger.progress("Suppressed: $suppressedList")
     }
 }
 
-- 
cgit 


From 379a2a8122849541201f4d9605511f5a03f86edc Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Tue, 7 Jul 2020 08:41:32 +0200
Subject: Change generic Error to IllegalStateException to be thrown when there
 are conflicting overrides

---
 core/src/main/kotlin/plugability/DokkaContext.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 59090522..61ae1918 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -127,7 +127,7 @@ private class DokkaContextConfigurationImpl(
 
     private fun findNotOverridden(bucket: Set<Extension<*, *, *>>): Extension<*, *, *> {
         val filtered = bucket.filter { it !in suppressedExtensions }
-        return filtered.singleOrNull() ?: throw Error("Conflicting overrides: $filtered")
+        return filtered.singleOrNull() ?: throw IllegalStateException("Conflicting overrides: $filtered")
     }
 
     private fun translateAdjacencyList(
-- 
cgit 


From e32e42e084d4e150387a7e9ec4ee00ae3974babd Mon Sep 17 00:00:00 2001
From: "sebastian.sellmair" <sebastian.sellmair@jetbrains.com>
Date: Wed, 15 Jul 2020 16:38:25 +0200
Subject: Use DokkaLogger instead of println and adjust log levels for less
 verbosity by default

---
 core/src/main/kotlin/DokkaBootstrapImpl.kt         | 13 -----------
 core/src/main/kotlin/DokkaGenerator.kt             |  9 ++++----
 core/src/main/kotlin/plugability/DokkaContext.kt   |  8 +++----
 core/src/main/kotlin/utilities/DokkaLogging.kt     | 25 +++++++++++-----------
 .../it/gradle/Android0GradleIntegrationTest.kt     |  2 +-
 .../dokka/it/gradle/BasicGradleIntegrationTest.kt  |  2 +-
 .../dokka/it/gradle/BasicGroovyIntegrationTest.kt  |  2 +-
 .../dokka/it/gradle/Multimodule0IntegrationTest.kt |  2 +-
 .../gradle/Multiplatform0GradleIntegrationTest.kt  |  2 +-
 .../src/main/kotlin/MavenDokkaLogger.kt            | 14 +-----------
 .../src/main/kotlin/testApi/logger/TestLogger.kt   |  7 +-----
 11 files changed, 28 insertions(+), 58 deletions(-)

(limited to 'core/src/main/kotlin/plugability')

diff --git a/core/src/main/kotlin/DokkaBootstrapImpl.kt b/core/src/main/kotlin/DokkaBootstrapImpl.kt
index 936fbe6c..fabbc889 100644
--- a/core/src/main/kotlin/DokkaBootstrapImpl.kt
+++ b/core/src/main/kotlin/DokkaBootstrapImpl.kt
@@ -66,19 +66,6 @@ class DokkaBootstrapImpl : DokkaBootstrap {
         override fun error(message: String) {
             consumer.accept("error", message).also { errorsCount++ }
         }
-
-        override fun report() {
-            if (warningsCount > 0 || errorsCount > 0) {
-                println(
-                    "Generation completed with $warningsCount warning" +
-                            (if (warningsCount == 1) "" else "s") +
-                            " and $errorsCount error" +
-                            if (errorsCount == 1) "" else "s"
-                )
-            } else {
-                println("generation completed successfully")
-            }
-        }
     }
 
     private lateinit var generator: DokkaGenerator
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index d694cc8c..4262d890 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -6,6 +6,7 @@ import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
+import org.jetbrains.dokka.utilities.report
 
 
 /**
@@ -17,7 +18,7 @@ class DokkaGenerator(
     private val configuration: DokkaConfiguration,
     private val logger: DokkaLogger
 ) {
-    fun generate() = timed {
+    fun generate() = timed(logger) {
         report("Initializing plugins")
         val context = initializePlugins(configuration, logger)
 
@@ -115,7 +116,7 @@ class DokkaGenerator(
 
     fun reportAfterRendering(context: DokkaContext) {
         context.unusedPoints.takeIf { it.isNotEmpty() }?.also {
-            logger.warn("Unused extension points found: ${it.joinToString(", ")}")
+            logger.info("Unused extension points found: ${it.joinToString(", ")}")
         }
 
         logger.report()
@@ -142,12 +143,12 @@ private class Timer(startTime: Long, private val logger: DokkaLogger?) {
     }
 
     fun dump(prefix: String = "") {
-        println(prefix)
+        logger?.info(prefix)
         val namePad = steps.map { it.first.length }.max() ?: 0
         val timePad = steps.windowed(2).map { (p1, p2) -> p2.second - p1.second }.max()?.toString()?.length ?: 0
         steps.windowed(2).forEach { (p1, p2) ->
             if (p1.first.isNotBlank()) {
-                println("${p1.first.padStart(namePad)}: ${(p2.second - p1.second).toString().padStart(timePad)}")
+                logger?.info("${p1.first.padStart(namePad)}: ${(p2.second - p1.second).toString().padStart(timePad)}")
             }
         }
     }
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 61ae1918..323039e9 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -205,9 +205,9 @@ private class DokkaContextConfigurationImpl(
                 "\t${it.key} by " + (it.value.singleOrNull() ?: it.value)
             }
 
-        logger.progress("Loaded plugins: $pluginNames")
-        logger.progress("Loaded: $loadedListForDebug")
-        logger.progress("Suppressed: $suppressedList")
+        logger.info("Loaded plugins: $pluginNames")
+        logger.info("Loaded: $loadedListForDebug")
+        logger.info("Suppressed: $suppressedList")
     }
 }
 
@@ -220,4 +220,4 @@ private fun checkClasspath(classLoader: URLClassLoader) {
     }
 }
 
-private fun <K, V> MutableMap<K, MutableList<V>>.listFor(key: K) = getOrPut(key, ::mutableListOf)
\ No newline at end of file
+private fun <K, V> MutableMap<K, MutableList<V>>.listFor(key: K) = getOrPut(key, ::mutableListOf)
diff --git a/core/src/main/kotlin/utilities/DokkaLogging.kt b/core/src/main/kotlin/utilities/DokkaLogging.kt
index 4b671f7b..6b8ed5d2 100644
--- a/core/src/main/kotlin/utilities/DokkaLogging.kt
+++ b/core/src/main/kotlin/utilities/DokkaLogging.kt
@@ -8,7 +8,18 @@ interface DokkaLogger {
     fun progress(message: String)
     fun warn(message: String)
     fun error(message: String)
-    fun report()
+}
+
+fun DokkaLogger.report() {
+    if (DokkaConsoleLogger.warningsCount > 0 || DokkaConsoleLogger.errorsCount > 0) {
+        info("Generation completed with ${DokkaConsoleLogger.warningsCount} warning" +
+                (if(DokkaConsoleLogger.warningsCount == 1) "" else "s") +
+                " and ${DokkaConsoleLogger.errorsCount} error" +
+                if(DokkaConsoleLogger.errorsCount == 1) "" else "s"
+        )
+    } else {
+        info("generation completed successfully")
+    }
 }
 
 object DokkaConsoleLogger : DokkaLogger {
@@ -24,16 +35,4 @@ object DokkaConsoleLogger : DokkaLogger {
     override fun warn(message: String) = println("WARN: $message").also { warningsCount++ }
 
     override fun error(message: String) = println("ERROR: $message").also { errorsCount++ }
-
-    override fun report() {
-        if (warningsCount > 0 || errorsCount > 0) {
-            println("Generation completed with $warningsCount warning" +
-                    (if(warningsCount == 1) "" else "s") +
-                    " and $errorsCount error" +
-                    if(errorsCount == 1) "" else "s"
-            )
-        } else {
-            println("generation completed successfully")
-        }
-    }
 }
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 19235597..30c3d07f 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
@@ -51,7 +51,7 @@ class Android0GradleIntegrationTest(override val versions: BuildVersions) : Abst
 
     @Test
     fun execute() {
-        val result = createGradleRunner("dokkaHtml", "--stacktrace").buildRelaxed()
+        val result = createGradleRunner("dokkaHtml", "-i", "-s").buildRelaxed()
         assertEquals(TaskOutcome.SUCCESS, assertNotNull(result.task(":dokkaHtml")).outcome)
 
         val htmlOutputDir = File(projectDir, "build/dokka/html")
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 c9c45d58..929c99aa 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
@@ -29,7 +29,7 @@ class BasicGradleIntegrationTest(override val versions: BuildVersions) : Abstrac
 
     @Test
     fun execute() {
-        val result = createGradleRunner("dokkaHtml", "dokkaJavadoc", "dokkaGfm", "dokkaJekyll", "--stacktrace")
+        val result = createGradleRunner("dokkaHtml", "dokkaJavadoc", "dokkaGfm", "dokkaJekyll", "-i", "-s")
             .buildRelaxed()
 
         assertEquals(TaskOutcome.SUCCESS, assertNotNull(result.task(":dokkaHtml")).outcome)
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 b20a7b2d..0d812ca9 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
@@ -33,7 +33,7 @@ class BasicGroovyIntegrationTest(override val versions: BuildVersions) : Abstrac
 
     @Test
     fun execute() {
-        val result = createGradleRunner("dokkaHtml", "dokkaJavadoc", "dokkaGfm", "dokkaJekyll", "--stacktrace")
+        val result = createGradleRunner("dokkaHtml", "dokkaJavadoc", "dokkaGfm", "dokkaJekyll", "-i", "-s")
             .buildRelaxed()
 
         assertEquals(TaskOutcome.SUCCESS, assertNotNull(result.task(":dokkaHtml")).outcome)
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 50ae22f9..64cf3d75 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
@@ -26,7 +26,7 @@ class Multimodule0IntegrationTest(override val versions: BuildVersions) : Abstra
 
     @Test
     fun execute() {
-        val result = createGradleRunner(":moduleA:dokkaHtmlMultimodule", "--stacktrace").buildRelaxed()
+        val result = createGradleRunner(":moduleA:dokkaHtmlMultimodule", "-i","-s").buildRelaxed()
 
         assertEquals(TaskOutcome.SUCCESS, assertNotNull(result.task(":moduleA:dokkaHtmlMultimodule")).outcome)
 
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 3e254dd0..d6d2ff6a 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
@@ -27,7 +27,7 @@ class Multiplatform0GradleIntegrationTest(override val versions: BuildVersions)
 
     @Test
     fun execute() {
-        val result = createGradleRunner("dokkaHtml", "--stacktrace").buildRelaxed()
+        val result = createGradleRunner("dokkaHtml", "-i", "-s").buildRelaxed()
 
         assertEquals(TaskOutcome.SUCCESS, assertNotNull(result.task(":dokkaHtml")).outcome)
 
diff --git a/runners/maven-plugin/src/main/kotlin/MavenDokkaLogger.kt b/runners/maven-plugin/src/main/kotlin/MavenDokkaLogger.kt
index 403fc773..4b5f4fa9 100644
--- a/runners/maven-plugin/src/main/kotlin/MavenDokkaLogger.kt
+++ b/runners/maven-plugin/src/main/kotlin/MavenDokkaLogger.kt
@@ -12,16 +12,4 @@ class MavenDokkaLogger(val log: Log) : DokkaLogger {
     override fun progress(message: String) = log.info(message)
     override fun warn(message: String) = log.warn(message).also { warningsCount++ }
     override fun error(message: String) = log.error(message).also { errorsCount++ }
-
-    override fun report() {
-        if (warningsCount > 0 || errorsCount > 0) {
-            log.info("Generation completed with $warningsCount warning" +
-                    (if(warningsCount == 1) "" else "s") +
-                    " and $errorsCount error" +
-                    if(errorsCount == 1) "" else "s"
-            )
-        } else {
-            log.info("generation completed successfully")
-        }
-    }
-}
\ No newline at end of file
+}
diff --git a/testApi/src/main/kotlin/testApi/logger/TestLogger.kt b/testApi/src/main/kotlin/testApi/logger/TestLogger.kt
index 8f88f88b..1dbe4a48 100644
--- a/testApi/src/main/kotlin/testApi/logger/TestLogger.kt
+++ b/testApi/src/main/kotlin/testApi/logger/TestLogger.kt
@@ -45,9 +45,4 @@ class TestLogger(private val logger: DokkaLogger) : DokkaLogger {
         _errorMessages.add(message)
         logger.error(message)
     }
-
-    override fun report() {
-        logger.report()
-    }
-
-}
\ No newline at end of file
+}
-- 
cgit