From ca3d34cc9e5be2d9616cfde3d2cac489c07bf102 Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Wed, 20 Nov 2019 15:20:04 +0100
Subject: Initial XML plugin 2

---
 plugins/xml/src/main/kotlin/XmlPlugin.kt           | 104 +++++++++++++++++++++
 .../org.jetbrains.dokka.plugability.DokkaPlugin    |   1 +
 2 files changed, 105 insertions(+)
 create mode 100644 plugins/xml/src/main/kotlin/XmlPlugin.kt
 create mode 100644 plugins/xml/src/main/resources/META-INF/services/org.jetbrains.dokka.plugability.DokkaPlugin

(limited to 'plugins/xml/src')

diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
new file mode 100644
index 00000000..4a932062
--- /dev/null
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -0,0 +1,104 @@
+package org.jetbrains.dokka.xml
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.DefaultExtra
+import org.jetbrains.dokka.Model.DocumentationNode
+import org.jetbrains.dokka.Model.dfs
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.*
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.transformers.PageNodeTransformer
+
+class XmlPlugin : DokkaPlugin() {
+    val transformer by extending {
+        CoreExtensions.pageTransformer with XmlTransformer
+    }
+}
+
+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 XmlTransformer : PageNodeTransformer {
+    enum class XMLKind : Kind {
+        Main, XmlList
+    }
+
+    override fun invoke(original: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode {
+        original.findAll { it is ClassPageNode }.forEach { node ->
+            val refs = node.documentationNode?.extra?.filterIsInstance<DefaultExtra>()?.filter { it.key == "@attr ref"}.orEmpty()
+            val elementsToAdd = mutableListOf<DocumentationNode<*>>()
+
+            refs.forEach { ref ->
+                val toFind = DRI.from(ref.value)
+                original.documentationNode?.dfs { it.dri == toFind }?.let { elementsToAdd.add(it) }
+            }
+
+            val refTable = ContentGroup(
+                listOf(
+                    ContentHeader(
+                        listOf(
+                            ContentText(
+                                "XML Attributes",
+                                DCI(node.dri, XMLKind.XmlList),
+                                node.platforms().toSet(), emptySet(), emptySet()
+                            )
+                        ),
+                        2,
+                        DCI(node.dri, XMLKind.Main),
+                        node.platforms().toSet(), emptySet(), emptySet()
+                    ),
+                    ContentTable(
+                        emptyList(),
+                        elementsToAdd.map {
+                            ContentGroup(
+                                listOf(
+                                    ContentDRILink(
+                                        listOf(
+                                            ContentText(
+                                                it.descriptors.first().name.toString(),
+                                                DCI(node.dri, XMLKind.Main),
+                                                node.platforms().toSet(), emptySet(), emptySet()
+                                            )
+                                        ),
+                                        it.dri,
+                                        DCI(it.dri, XMLKind.XmlList),
+                                        it.platformData.toSet(), emptySet(), emptySet()
+                                    ),
+                                    ContentText(
+                                        it.briefDocstring,
+                                        DCI(it.dri, XMLKind.XmlList),
+                                        it.platformData.toSet(), emptySet(), emptySet()
+                                    )
+                                ),
+                                DCI(node.dri, XMLKind.XmlList),
+                                node.platforms().toSet(), emptySet(), emptySet()
+                            )
+                        },
+                        DCI(node.dri, XMLKind.XmlList),
+                        node.platforms().toSet(), emptySet(), emptySet()
+                    )
+                ),
+                DCI(node.dri, XMLKind.XmlList),
+                node.platforms().toSet(), emptySet(), emptySet()
+            )
+
+            val content = node.content as ContentGroup
+            val children = (node.content as ContentGroup).children
+            node.content = content.copy(children = children + refTable)
+        }
+        return original
+    }
+
+    private fun PageNode.findAll(predicate: (PageNode) -> Boolean): Set<PageNode> {
+        val found = mutableSetOf<PageNode>()
+        if (predicate(this)) {
+            found.add(this)
+        } else {
+            this.children.asSequence().mapNotNull { it.findAll(predicate) }.forEach { found.addAll(it) }
+        }
+        return found
+    }
+
+    private fun PageNode.platforms() = this.content.platforms.toList()
+}
\ No newline at end of file
diff --git a/plugins/xml/src/main/resources/META-INF/services/org.jetbrains.dokka.plugability.DokkaPlugin b/plugins/xml/src/main/resources/META-INF/services/org.jetbrains.dokka.plugability.DokkaPlugin
new file mode 100644
index 00000000..ebc3e551
--- /dev/null
+++ b/plugins/xml/src/main/resources/META-INF/services/org.jetbrains.dokka.plugability.DokkaPlugin
@@ -0,0 +1 @@
+org.jetbrains.dokka.xml.XmlPlugin
-- 
cgit 


From 4f59d3df7a0a3525bf3a0dab8617746a4db30f67 Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Wed, 20 Nov 2019 17:42:45 +0100
Subject: XML plugin refactoring

---
 plugins/xml/src/main/kotlin/XmlPlugin.kt |  65 +++------------
 plugins/xml/src/main/kotlin/utils.kt     | 135 +++++++++++++++++++++++++++++++
 2 files changed, 144 insertions(+), 56 deletions(-)
 create mode 100644 plugins/xml/src/main/kotlin/utils.kt

(limited to 'plugins/xml/src')

diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index 4a932062..4023e1cc 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -16,78 +16,31 @@ class XmlPlugin : 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 XmlTransformer : PageNodeTransformer {
     enum class XMLKind : Kind {
         Main, XmlList
     }
 
-    override fun invoke(original: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode {
-        original.findAll { it is ClassPageNode }.forEach { node ->
+    override fun invoke(input: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode {
+        input.findAll { it is ClassPageNode }.forEach { node ->
             val refs = node.documentationNode?.extra?.filterIsInstance<DefaultExtra>()?.filter { it.key == "@attr ref"}.orEmpty()
             val elementsToAdd = mutableListOf<DocumentationNode<*>>()
 
             refs.forEach { ref ->
                 val toFind = DRI.from(ref.value)
-                original.documentationNode?.dfs { it.dri == toFind }?.let { elementsToAdd.add(it) }
+                input.documentationNode?.dfs { it.dri == toFind }?.let { elementsToAdd.add(it) }
+            }
+            val refTable = group(node.platforms().toSet(), node.dri, XMLKind.XmlList) {
+                table("XML Attributes", 2, XMLKind.XmlList, elementsToAdd) {
+                    elementsToAdd.map { row(it) }
+                }
             }
-
-            val refTable = ContentGroup(
-                listOf(
-                    ContentHeader(
-                        listOf(
-                            ContentText(
-                                "XML Attributes",
-                                DCI(node.dri, XMLKind.XmlList),
-                                node.platforms().toSet(), emptySet(), emptySet()
-                            )
-                        ),
-                        2,
-                        DCI(node.dri, XMLKind.Main),
-                        node.platforms().toSet(), emptySet(), emptySet()
-                    ),
-                    ContentTable(
-                        emptyList(),
-                        elementsToAdd.map {
-                            ContentGroup(
-                                listOf(
-                                    ContentDRILink(
-                                        listOf(
-                                            ContentText(
-                                                it.descriptors.first().name.toString(),
-                                                DCI(node.dri, XMLKind.Main),
-                                                node.platforms().toSet(), emptySet(), emptySet()
-                                            )
-                                        ),
-                                        it.dri,
-                                        DCI(it.dri, XMLKind.XmlList),
-                                        it.platformData.toSet(), emptySet(), emptySet()
-                                    ),
-                                    ContentText(
-                                        it.briefDocstring,
-                                        DCI(it.dri, XMLKind.XmlList),
-                                        it.platformData.toSet(), emptySet(), emptySet()
-                                    )
-                                ),
-                                DCI(node.dri, XMLKind.XmlList),
-                                node.platforms().toSet(), emptySet(), emptySet()
-                            )
-                        },
-                        DCI(node.dri, XMLKind.XmlList),
-                        node.platforms().toSet(), emptySet(), emptySet()
-                    )
-                ),
-                DCI(node.dri, XMLKind.XmlList),
-                node.platforms().toSet(), emptySet(), emptySet()
-            )
 
             val content = node.content as ContentGroup
             val children = (node.content as ContentGroup).children
             node.content = content.copy(children = children + refTable)
         }
-        return original
+        return input
     }
 
     private fun PageNode.findAll(predicate: (PageNode) -> Boolean): Set<PageNode> {
diff --git a/plugins/xml/src/main/kotlin/utils.kt b/plugins/xml/src/main/kotlin/utils.kt
new file mode 100644
index 00000000..510f3328
--- /dev/null
+++ b/plugins/xml/src/main/kotlin/utils.kt
@@ -0,0 +1,135 @@
+package org.jetbrains.dokka.xml
+
+import org.jetbrains.dokka.Model.DocumentationNode
+import org.jetbrains.dokka.links.DRI
+import org.jetbrains.dokka.pages.*
+
+internal class ContentBuilder(
+    val platforms: Set<PlatformData>,
+    val dri: DRI,
+    val kind: Kind,
+    val styles: Set<Style> = emptySet(),
+    val extras: Set<Extra> = emptySet()
+) {
+    private val contents = mutableListOf<ContentNode>()
+
+    fun build() = ContentGroup(
+        contents.toList(),
+        DCI(dri, kind),
+        platforms,
+        styles,
+        extras
+    )
+
+    fun header(level: Int, block: ContentBuilder.() -> Unit) {
+        contents += ContentHeader(level, group(ContentKind.Symbol, block))
+    }
+
+    private fun createText(text: String) =
+        ContentText(text, DCI(dri, ContentKind.Symbol), platforms, styles, extras)
+
+    fun text(text: String) {
+        contents += createText(text)
+    }
+
+    inline fun <T : Any> block(
+        name: String,
+        level: Int,
+        kind: Kind,
+        elements: Iterable<T>,
+        platformData: Set<PlatformData>,
+        operation: ContentBuilder.(T) -> Unit
+    ) {
+        header(level) { text(name) }
+
+        contents += ContentTable(
+            emptyList(),
+            elements.map { group(platforms, dri, kind) { operation(it) } },
+            DCI(dri, kind),
+            platformData, styles, extras
+        )
+    }
+
+    inline fun <T> list(
+        elements: List<T>,
+        prefix: String = "",
+        suffix: String = "",
+        separator: String = ", ",
+        block: ContentBuilder.(T) -> Unit
+    ) {
+        if (elements.isNotEmpty()) {
+            if (prefix.isNotEmpty()) text(prefix)
+            elements.dropLast(1).forEach {
+                block(it)
+                text(separator)
+            }
+            block(elements.last())
+            if (suffix.isNotEmpty()) text(suffix)
+        }
+    }
+
+    fun link(text: String, address: DRI) {
+        contents += ContentDRILink(
+            listOf(createText(text)),
+            address,
+            DCI(dri, ContentKind.Symbol),
+            platforms
+        )
+    }
+
+    fun <T: DocumentationNode<*>> table(
+        name: String,
+        level: Int,
+        kind: Kind,
+        elements: Iterable<T>,
+        operation: ContentBuilder.(T) -> Unit
+    ) {
+        header(level) { text(name) }
+
+        contents += ContentTable(
+            emptyList(),
+            elements.map { row(it) }.toList(),
+            DCI(dri, kind),
+            platforms, emptySet(), emptySet()
+        )
+    }
+
+
+    fun row(element: DocumentationNode<*>) =
+        ContentGroup(
+            listOf(
+                ContentDRILink(
+                    listOf(
+                        ContentText(
+                            element.descriptors.first().name.toString(),
+                            DCI(dri, XmlTransformer.XMLKind.Main),
+                            platforms, emptySet(), emptySet()
+                        )
+                    ),
+                    element.dri,
+                    DCI(element.dri, XmlTransformer.XMLKind.XmlList),
+                    element.platformData.toSet(), emptySet(), emptySet()
+                ),
+                ContentText(
+                    element.briefDocstring,
+                    DCI(element.dri, XmlTransformer.XMLKind.XmlList),
+                    element.platformData.toSet(), emptySet(), emptySet()
+                )
+            ),
+            DCI(dri, XmlTransformer.XMLKind.XmlList),
+            platforms, emptySet(), emptySet()
+        )
+
+
+    private inline fun group(kind: Kind, block: ContentBuilder.() -> Unit): ContentGroup =
+        group(platforms, dri, kind, block)
+}
+
+internal inline fun group(
+    platforms: Set<PlatformData>,
+    dri: DRI,
+    kind: Kind = ContentKind.Main,
+    block: ContentBuilder.() -> Unit
+) = ContentBuilder(platforms, dri, kind).apply(block).build()
+
+
-- 
cgit 


From 4b1a3a2cbe62f98c9f1b472e70d754645d7f8641 Mon Sep 17 00:00:00 2001
From: Błażej Kardyś <bkardys@virtuslab.com>
Date: Tue, 26 Nov 2019 14:39:06 +0100
Subject: Merging PageNode changes with plugins

---
 core/src/main/kotlin/Model/DocumentationNode.kt    |  26 +---
 core/src/main/kotlin/pages/PageContentBuilder.kt   |  86 +++++++------
 core/src/main/kotlin/pages/PageNodes.kt            |   8 ++
 .../DefaultDocumentationToPageTransformer.kt       |   2 +-
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt   |   2 +-
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |  62 +++++-----
 plugins/xml/src/main/kotlin/utils.kt               | 136 +--------------------
 7 files changed, 102 insertions(+), 220 deletions(-)

(limited to 'plugins/xml/src')

diff --git a/core/src/main/kotlin/Model/DocumentationNode.kt b/core/src/main/kotlin/Model/DocumentationNode.kt
index 623f2ea3..0adb37b5 100644
--- a/core/src/main/kotlin/Model/DocumentationNode.kt
+++ b/core/src/main/kotlin/Model/DocumentationNode.kt
@@ -18,12 +18,12 @@ class Package(
     override val classes: List<Class>,
     override val extra: MutableSet<Extra> = mutableSetOf()
 ) : ScopeNode() {
-    val name = dri.packageName.orEmpty()
+    override val name = dri.packageName.orEmpty()
 }
 
 class Class(
     override val dri: DRI,
-    val name: String,
+    override val name: String,
     val kind: ClassKind,
     val constructors: List<Function>,
     override val functions: List<Function>,
@@ -38,7 +38,7 @@ class Class(
 
 class Function(
     override val dri: DRI,
-    val name: String,
+    override val name: String,
     val returnType: TypeWrapper?,
     val isConstructor: Boolean,
     override val receiver: Parameter?,
@@ -53,7 +53,7 @@ class Function(
 
 class Property(
     override val dri: DRI,
-    val name: String,
+    override val name: String,
     override val receiver: Parameter?,
     override val expected: PlatformInfo?,
     override val actual: List<PlatformInfo>,
@@ -66,7 +66,7 @@ class Property(
 // TODO: treat named Parameters and receivers differently
 class Parameter(
     override val dri: DRI,
-    val name: String?,
+    override val name: String?,
     val type: TypeWrapper,
     override val actual: List<PlatformInfo>,
     override val extra: MutableSet<Extra> = mutableSetOf()
@@ -102,6 +102,7 @@ class ClassPlatformInfo(
 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() }
 
@@ -151,11 +152,6 @@ interface TypeWrapper {
 }
 interface ClassKind
 
-fun DocumentationNode.walk(process: DocumentationNode.() -> Unit) {
-    this.process()
-    this.children.forEach { it.process() }
-}
-
 fun DocumentationNode.dfs(predicate: (DocumentationNode) -> Boolean): DocumentationNode? =
     if (predicate(this)) {
         this
@@ -163,14 +159,4 @@ fun DocumentationNode.dfs(predicate: (DocumentationNode) -> Boolean): Documentat
         this.children.asSequence().mapNotNull { it.dfs(predicate) }.firstOrNull()
     }
 
-fun DocumentationNode.findAll(predicate: (DocumentationNode) -> Boolean): Set<DocumentationNode> {
-    val found = mutableSetOf<DocumentationNode>()
-    if (predicate(this)) {
-        found.add(this)
-    } else {
-        this.children.asSequence().mapNotNull { it.findAll(predicate) }.forEach { found.addAll(it) }
-    }
-    return found
-}
-
 interface Extra
\ No newline at end of file
diff --git a/core/src/main/kotlin/pages/PageContentBuilder.kt b/core/src/main/kotlin/pages/PageContentBuilder.kt
index 9d07a098..2341a59d 100644
--- a/core/src/main/kotlin/pages/PageContentBuilder.kt
+++ b/core/src/main/kotlin/pages/PageContentBuilder.kt
@@ -9,7 +9,8 @@ import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.parseMarkdown
 
 class DefaultPageContentBuilder(
-    private val node: DocumentationNode,
+    private val dri: DRI,
+    private val platformData: Set<PlatformData>,
     private val kind: Kind,
     private val markdownConverter: MarkdownToContentConverter,
     val logger: DokkaLogger,
@@ -18,13 +19,13 @@ class DefaultPageContentBuilder(
 ) : PageContentBuilder {
     private val contents = mutableListOf<ContentNode>()
 
-    private fun createText(text: String) =
-        ContentText(text, DCI(node.dri, ContentKind.Symbol), node.platformData, styles, extras)
+    private fun createText(text: String, kind: Kind = ContentKind.Symbol) =
+        ContentText(text, DCI(dri, kind), platformData, styles, extras)
 
     private fun build() = ContentGroup(
         contents.toList(),
-        DCI(node.dri, kind),
-        node.platformData,
+        DCI(dri, kind),
+        platformData,
         styles,
         extras
     )
@@ -33,12 +34,12 @@ class DefaultPageContentBuilder(
         contents += ContentHeader(level, group(ContentKind.Symbol, block))
     }
 
-    override fun text(text: String) {
-        contents += createText(text)
+    override fun text(text: String, kind: Kind) {
+        contents += createText(text, kind)
     }
 
     private fun signature(f: Function, block: PageContentBuilderFunction) {
-        contents += group(f, ContentKind.Symbol, block)
+        contents += group(f.dri, f.platformData, ContentKind.Symbol, block)
     }
 
     override fun signature(f: Function) = signature(f) {
@@ -49,7 +50,7 @@ class DefaultPageContentBuilder(
         }
         link(f.name, f.dri)
         text("(")
-        list(f.parameters, "", "", ", ") {
+        list(f.parameters) {
             link(it.name!!, it.dri)
             text(": ")
             type(it.type)
@@ -66,9 +67,9 @@ class DefaultPageContentBuilder(
     override fun linkTable(elements: List<DRI>) {
         contents += ContentTable(
             emptyList(),
-            elements.map { group(node, ContentKind.Classes) { link(it.classNames ?: "", it) } },
-            DCI(node.dri, kind),
-            node.platformData, styles, extras
+            elements.map { group(dri, platformData, ContentKind.Classes) { link(it.classNames ?: "", it) } },
+            DCI(dri, kind),
+            platformData, styles, extras
         )
     }
 
@@ -84,8 +85,8 @@ class DefaultPageContentBuilder(
 
         contents += ContentTable(
             emptyList(),
-            elements.map { group(it, kind) { operation(it) } },
-            DCI(node.dri, kind),
+            elements.map { group(it.dri, it.platformData, kind) { operation(it) } },
+            DCI(dri, kind),
             platformData, styles, extras
         )
     }
@@ -108,12 +109,21 @@ class DefaultPageContentBuilder(
         }
     }
 
-    override fun link(text: String, address: DRI) {
+    override fun link(text: String, address: DRI, kind: Kind) {
         contents += ContentDRILink(
             listOf(createText(text)),
             address,
-            DCI(node.dri, ContentKind.Symbol),
-            node.platformData
+            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
         )
     }
 
@@ -122,8 +132,8 @@ class DefaultPageContentBuilder(
             with(this as DefaultPageContentBuilder) {
                 contents += markdownConverter.buildContent(
                     parseMarkdown(raw),
-                    DCI(node.dri, ContentKind.Comment),
-                    node.platformData,
+                    DCI(dri, ContentKind.Comment),
+                    platformData,
                     links
                 )
             }
@@ -132,30 +142,32 @@ class DefaultPageContentBuilder(
 
     override fun markdown(raw: String, links: Map<String, DRI>) {
         contents += markdownConverter.buildContent(
-            parseMarkdown(raw), DCI(node.dri, ContentKind.Sample),
-            node.platformData,
+            parseMarkdown(raw), DCI(dri, ContentKind.Sample),
+            platformData,
             links
         )
     }
 
-    private fun group(kind: Kind, block: PageContentBuilderFunction): ContentGroup =
-        group(node, kind, block)
+    fun group(kind: Kind, block: PageContentBuilderFunction): ContentGroup =
+        group(dri, platformData, kind, block)
 
     override fun group(
-        node: DocumentationNode,
+        dri: DRI,
+        platformData: Set<PlatformData>,
         kind: Kind,
         block: PageContentBuilderFunction
-    ): ContentGroup = group(node, kind, markdownConverter, logger, block)
+    ): ContentGroup = group(dri, platformData, kind, markdownConverter, logger, block)
 
     companion object {
         fun group(
-            node: DocumentationNode,
+            dri: DRI,
+            platformData: Set<PlatformData>,
             kind: Kind,
             markdownConverter: MarkdownToContentConverter,
             logger: DokkaLogger,
             block: PageContentBuilderFunction
         ): ContentGroup =
-            DefaultPageContentBuilder(node, kind, markdownConverter, logger).apply(block).build()
+            DefaultPageContentBuilder(dri, platformData, kind, markdownConverter, logger).apply(block).build()
     }
 }
 
@@ -167,7 +179,7 @@ private fun PageContentBuilder.type(t: TypeWrapper) {
             logger.error("type $t cannot be resolved")
             text("???")
         }
-    list(t.arguments, prefix = "<", suffix = ">", separator = ", ") {
+    list(t.arguments, prefix = "<", suffix = ">") {
         type(it)
     }
 }
@@ -179,19 +191,23 @@ annotation class ContentMarker
 
 @ContentMarker
 interface PageContentBuilder {
-    fun group(node: DocumentationNode, kind: Kind, block: PageContentBuilderFunction): ContentGroup
-    fun text(text: String)
+    fun group(
+        dri: 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)
+    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 header(level: Int, block: PageContentBuilder.() -> Unit)
+    fun header(level: Int, block: PageContentBuilderFunction)
     fun <T> list(
         elements: List<T>,
-        prefix: String,
-        suffix: String,
-        separator: String,
+        prefix: String =  "",
+        suffix: String =  "",
+        separator: String = ",",
         operation: PageContentBuilder.(T) -> Unit
     )
 
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index a07aa8c1..cf5bf453 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -58,6 +58,14 @@ class ModulePageNode(
     ): ModulePageNode =
         if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
         else ModulePageNode(name, content, documentationNode, children, embeddedResources)
+
+    private fun PageNode.transformNode(operation: (PageNode) -> PageNode): PageNode =
+        operation(this).let { newNode ->
+            newNode.modified(children = newNode.children.map { it.transformNode(operation) })
+        }
+
+    fun transformPageNodeTree(operation: (PageNode) -> PageNode) =
+        this.transformNode(operation) as ModulePageNode
 }
 
 class PackagePageNode(
diff --git a/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt b/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
index 4c44ecdf..b0877527 100644
--- a/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
+++ b/core/src/main/kotlin/transformers/DefaultDocumentationToPageTransformer.kt
@@ -14,7 +14,7 @@ class DefaultDocumentationToPageTransformer(
 ) : DocumentationToPageTransformer {
     override fun transform(module: Module): ModulePageNode =
         DefaultPageBuilder { node, kind, operation ->
-            DefaultPageContentBuilder.group(node, kind, markdownConverter, logger, operation)
+            DefaultPageContentBuilder.group(node.dri, node.platformData, kind, markdownConverter, logger, operation)
         }.pageForModule(module)
 
 }
\ 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 63512966..0decfb1c 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?.descriptors
+        get() = documentationNode?.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 4023e1cc..5be0eca4 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -2,6 +2,7 @@ package org.jetbrains.dokka.xml
 
 import org.jetbrains.dokka.CoreExtensions
 import org.jetbrains.dokka.DefaultExtra
+import org.jetbrains.dokka.DokkaConsoleLogger
 import org.jetbrains.dokka.Model.DocumentationNode
 import org.jetbrains.dokka.Model.dfs
 import org.jetbrains.dokka.links.DRI
@@ -9,6 +10,7 @@ import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.transformers.PageNodeTransformer
+import javax.xml.bind.annotation.XmlList
 
 class XmlPlugin : DokkaPlugin() {
     val transformer by extending {
@@ -21,36 +23,40 @@ object XmlTransformer : PageNodeTransformer {
         Main, XmlList
     }
 
-    override fun invoke(input: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode {
-        input.findAll { it is ClassPageNode }.forEach { node ->
-            val refs = node.documentationNode?.extra?.filterIsInstance<DefaultExtra>()?.filter { it.key == "@attr ref"}.orEmpty()
-            val elementsToAdd = mutableListOf<DocumentationNode<*>>()
-
-            refs.forEach { ref ->
-                val toFind = DRI.from(ref.value)
-                input.documentationNode?.dfs { it.dri == toFind }?.let { elementsToAdd.add(it) }
-            }
-            val refTable = group(node.platforms().toSet(), node.dri, XMLKind.XmlList) {
-                table("XML Attributes", 2, XMLKind.XmlList, elementsToAdd) {
-                    elementsToAdd.map { row(it) }
+    override fun invoke(input: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode =
+        input.transformPageNodeTree { node ->
+            if (node !is ClassPageNode) node
+            else {
+                val refs =
+                    node.documentationNode?.extra?.filterIsInstance<DefaultExtra>()?.filter { it.key == "@attr ref" }
+                        .orEmpty()
+                val elementsToAdd = mutableListOf<DocumentationNode>()
+
+                refs.forEach { ref ->
+                    val toFind = DRI.from(ref.value)
+                    input.documentationNode?.dfs { it.dri == toFind }?.let { elementsToAdd.add(it) }
+                }
+                val platformData = node.platforms().toSet()
+                val refTable = DefaultPageContentBuilder.group(
+                    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
+                ) {
+                    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)
+                    }
                 }
-            }
-
-            val content = node.content as ContentGroup
-            val children = (node.content as ContentGroup).children
-            node.content = content.copy(children = children + refTable)
-        }
-        return input
-    }
 
-    private fun PageNode.findAll(predicate: (PageNode) -> Boolean): Set<PageNode> {
-        val found = mutableSetOf<PageNode>()
-        if (predicate(this)) {
-            found.add(this)
-        } else {
-            this.children.asSequence().mapNotNull { it.findAll(predicate) }.forEach { found.addAll(it) }
-        }
-        return found
+                val content = node.content as ContentGroup
+                val children = (node.content as ContentGroup).children
+                node.modified(content = content.copy(children = children + refTable))
+            }
     }
 
     private fun PageNode.platforms() = this.content.platforms.toList()
diff --git a/plugins/xml/src/main/kotlin/utils.kt b/plugins/xml/src/main/kotlin/utils.kt
index 510f3328..2f5f1893 100644
--- a/plugins/xml/src/main/kotlin/utils.kt
+++ b/plugins/xml/src/main/kotlin/utils.kt
@@ -1,135 +1 @@
-package org.jetbrains.dokka.xml
-
-import org.jetbrains.dokka.Model.DocumentationNode
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.pages.*
-
-internal class ContentBuilder(
-    val platforms: Set<PlatformData>,
-    val dri: DRI,
-    val kind: Kind,
-    val styles: Set<Style> = emptySet(),
-    val extras: Set<Extra> = emptySet()
-) {
-    private val contents = mutableListOf<ContentNode>()
-
-    fun build() = ContentGroup(
-        contents.toList(),
-        DCI(dri, kind),
-        platforms,
-        styles,
-        extras
-    )
-
-    fun header(level: Int, block: ContentBuilder.() -> Unit) {
-        contents += ContentHeader(level, group(ContentKind.Symbol, block))
-    }
-
-    private fun createText(text: String) =
-        ContentText(text, DCI(dri, ContentKind.Symbol), platforms, styles, extras)
-
-    fun text(text: String) {
-        contents += createText(text)
-    }
-
-    inline fun <T : Any> block(
-        name: String,
-        level: Int,
-        kind: Kind,
-        elements: Iterable<T>,
-        platformData: Set<PlatformData>,
-        operation: ContentBuilder.(T) -> Unit
-    ) {
-        header(level) { text(name) }
-
-        contents += ContentTable(
-            emptyList(),
-            elements.map { group(platforms, dri, kind) { operation(it) } },
-            DCI(dri, kind),
-            platformData, styles, extras
-        )
-    }
-
-    inline fun <T> list(
-        elements: List<T>,
-        prefix: String = "",
-        suffix: String = "",
-        separator: String = ", ",
-        block: ContentBuilder.(T) -> Unit
-    ) {
-        if (elements.isNotEmpty()) {
-            if (prefix.isNotEmpty()) text(prefix)
-            elements.dropLast(1).forEach {
-                block(it)
-                text(separator)
-            }
-            block(elements.last())
-            if (suffix.isNotEmpty()) text(suffix)
-        }
-    }
-
-    fun link(text: String, address: DRI) {
-        contents += ContentDRILink(
-            listOf(createText(text)),
-            address,
-            DCI(dri, ContentKind.Symbol),
-            platforms
-        )
-    }
-
-    fun <T: DocumentationNode<*>> table(
-        name: String,
-        level: Int,
-        kind: Kind,
-        elements: Iterable<T>,
-        operation: ContentBuilder.(T) -> Unit
-    ) {
-        header(level) { text(name) }
-
-        contents += ContentTable(
-            emptyList(),
-            elements.map { row(it) }.toList(),
-            DCI(dri, kind),
-            platforms, emptySet(), emptySet()
-        )
-    }
-
-
-    fun row(element: DocumentationNode<*>) =
-        ContentGroup(
-            listOf(
-                ContentDRILink(
-                    listOf(
-                        ContentText(
-                            element.descriptors.first().name.toString(),
-                            DCI(dri, XmlTransformer.XMLKind.Main),
-                            platforms, emptySet(), emptySet()
-                        )
-                    ),
-                    element.dri,
-                    DCI(element.dri, XmlTransformer.XMLKind.XmlList),
-                    element.platformData.toSet(), emptySet(), emptySet()
-                ),
-                ContentText(
-                    element.briefDocstring,
-                    DCI(element.dri, XmlTransformer.XMLKind.XmlList),
-                    element.platformData.toSet(), emptySet(), emptySet()
-                )
-            ),
-            DCI(dri, XmlTransformer.XMLKind.XmlList),
-            platforms, emptySet(), emptySet()
-        )
-
-
-    private inline fun group(kind: Kind, block: ContentBuilder.() -> Unit): ContentGroup =
-        group(platforms, dri, kind, block)
-}
-
-internal inline fun group(
-    platforms: Set<PlatformData>,
-    dri: DRI,
-    kind: Kind = ContentKind.Main,
-    block: ContentBuilder.() -> Unit
-) = ContentBuilder(platforms, dri, kind).apply(block).build()
-
-
+package org.jetbrains.dokka.xml
\ No newline at end of file
-- 
cgit 


From 7e87c8ac4b7b3987df1722d7b9a6d3b2c5b169a4 Mon Sep 17 00:00:00 2001
From: Kamil Doległo <kamilok1965@interia.pl>
Date: Tue, 26 Nov 2019 18:12:23 +0100
Subject: Fix XMLPlugin after changes in DRIs

---
 core/src/main/kotlin/DokkaDescriptorVisitor.kt |  4 ++--
 plugins/xml/src/main/kotlin/XmlPlugin.kt       | 11 ++++-------
 2 files changed, 6 insertions(+), 9 deletions(-)

(limited to 'plugins/xml/src')

diff --git a/core/src/main/kotlin/DokkaDescriptorVisitor.kt b/core/src/main/kotlin/DokkaDescriptorVisitor.kt
index bb914a27..6c82f2c3 100644
--- a/core/src/main/kotlin/DokkaDescriptorVisitor.kt
+++ b/core/src/main/kotlin/DokkaDescriptorVisitor.kt
@@ -165,11 +165,11 @@ class DokkaDescriptorVisitor(
                     descriptor,
                     null,
                     toFind.split('.')
-                ).map { DefaultExtra("@attr ref", DRI.from(it).toString()) }
+                ).map { XMLMega("@attr ref", DRI.from(it)) }
             }.orEmpty()
 }
 
-data class DefaultExtra(val key: String, val value: String) : Extra
+data class XMLMega(val key: String, val dri: DRI) : Extra
 
 enum class KotlinClassKindTypes : ClassKind {
     CLASS,
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index 5be0eca4..9de706b2 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -1,16 +1,14 @@
 package org.jetbrains.dokka.xml
 
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.DefaultExtra
 import org.jetbrains.dokka.DokkaConsoleLogger
 import org.jetbrains.dokka.Model.DocumentationNode
 import org.jetbrains.dokka.Model.dfs
-import org.jetbrains.dokka.links.DRI
+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 javax.xml.bind.annotation.XmlList
 
 class XmlPlugin : DokkaPlugin() {
     val transformer by extending {
@@ -28,13 +26,12 @@ object XmlTransformer : PageNodeTransformer {
             if (node !is ClassPageNode) node
             else {
                 val refs =
-                    node.documentationNode?.extra?.filterIsInstance<DefaultExtra>()?.filter { it.key == "@attr ref" }
+                    node.documentationNode?.extra?.filterIsInstance<XMLMega>()?.filter { it.key == "@attr ref" }
                         .orEmpty()
                 val elementsToAdd = mutableListOf<DocumentationNode>()
 
                 refs.forEach { ref ->
-                    val toFind = DRI.from(ref.value)
-                    input.documentationNode?.dfs { it.dri == toFind }?.let { elementsToAdd.add(it) }
+                    input.documentationNode?.dfs { it.dri == ref.dri }?.let { elementsToAdd.add(it) }
                 }
                 val platformData = node.platforms().toSet()
                 val refTable = DefaultPageContentBuilder.group(
@@ -57,7 +54,7 @@ object XmlTransformer : PageNodeTransformer {
                 val children = (node.content as ContentGroup).children
                 node.modified(content = content.copy(children = children + refTable))
             }
-    }
+        }
 
     private fun PageNode.platforms() = this.content.platforms.toList()
 }
\ 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 'plugins/xml/src')

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 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 'plugins/xml/src')

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 'plugins/xml/src')

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 'plugins/xml/src')

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 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 'plugins/xml/src')

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 885ecd28153b484277c9ddcbf4a7f9d761a59545 Mon Sep 17 00:00:00 2001
From: Paweł Marks <pmarks@virtuslab.com>
Date: Mon, 27 Jan 2020 09:34:16 +0100
Subject: Unifing model for pages with content ant technical renderer specific
 pages

---
 core/src/main/kotlin/DokkaGenerator.kt             |   7 +-
 core/src/main/kotlin/pages/PageNodes.kt            |  92 +++++++++-----
 core/src/main/kotlin/pages/RendererSpecificPage.kt |  40 ++++++
 core/src/main/kotlin/renderers/DefaultRenderer.kt  |  71 +++++++----
 core/src/main/kotlin/renderers/FileWriter.kt       |   6 +-
 core/src/main/kotlin/renderers/HtmlRenderer.kt     | 138 +++++++--------------
 core/src/main/kotlin/renderers/Renderer.kt         |   4 +-
 .../src/main/kotlin/renderers/htmlPreprocessors.kt |  57 +++++++++
 .../kotlin/resolvers/DefaultLocationProvider.kt    |  81 ++++++------
 core/src/main/kotlin/resolvers/LocationProvider.kt |   6 +-
 .../kotlin/resolvers/LocationProviderFactory.kt    |   5 +-
 .../DefaultDocumentationNodeMerger.kt              |   1 -
 .../transformers/pages/PageNodeTransformer.kt      |   3 +-
 core/src/main/kotlin/utilities/nodeDebug.kt        |   2 +-
 .../resources/dokka/scripts/navigationLoader.js    |   0
 plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt   |  20 ++-
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |  68 +++++-----
 .../main/kotlin/testApi/testRunner/TestRunner.kt   |   5 +-
 18 files changed, 349 insertions(+), 257 deletions(-)
 create mode 100644 core/src/main/kotlin/pages/RendererSpecificPage.kt
 create mode 100644 core/src/main/kotlin/renderers/htmlPreprocessors.kt
 create mode 100644 core/src/main/resources/dokka/scripts/navigationLoader.js

(limited to 'plugins/xml/src')

diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index 95f9e647..add7eedb 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -8,6 +8,7 @@ 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.single
 import org.jetbrains.dokka.utilities.DokkaLogger
@@ -88,12 +89,12 @@ class DokkaGenerator(
     ) = context.single(CoreExtensions.documentationToPageTranslator).invoke(transformedDocumentation, context)
 
     fun transformPages(
-        pages: ModulePageNode,
+        pages: RootPageNode,
         context: DokkaContext
-    ) = context[CoreExtensions.pageTransformer].fold(pages) { acc, t -> t(acc, context) }
+    ) = context[CoreExtensions.pageTransformer].fold(pages) { acc, t -> t(acc) }
 
     fun render(
-        transformedPages: ModulePageNode,
+        transformedPages: RootPageNode,
         context: DokkaContext
     ) {
         val renderer = context.single(CoreExtensions.renderer)
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index 9274ac2b..80b21547 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -7,18 +7,57 @@ import java.util.*
 
 interface PageNode {
     val name: String
+    val children: List<PageNode>
+
+    fun modified(
+        name: String = this.name,
+        children: List<PageNode> = this.children
+    ): PageNode
+}
+
+interface ContentPage: PageNode {
     val content: ContentNode
     val dri: DRI
     val documentable: Documentable?
     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
+    ): ContentPage
+}
+
+abstract class RootPageNode: PageNode {
+    val parentMap: Map<PageNode, PageNode> by lazy {
+        IdentityHashMap<PageNode, PageNode>().apply {
+            fun process(parent: PageNode) {
+                parent.children.forEach {  child ->
+                    put(child, parent)
+                    process(child)
+                }
+            }
+            process(this@RootPageNode)
+        }
+    }
+
+    fun transformPageNodeTree(operation: (PageNode) -> PageNode) =
+        this.transformNode(operation) as RootPageNode
+
+    fun transformContentPagesTree(operation: (ContentPage) -> ContentPage) = transformPageNodeTree {
+        if (it is ContentPage) operation(it) else it
+    } as RootPageNode
+
+    private fun PageNode.transformNode(operation: (PageNode) -> PageNode): PageNode =
+        operation(this).let { newNode ->
+            newNode.modified(children = newNode.children.map { it.transformNode(operation) })
+        }
+
+    abstract override fun modified(
+        name: String,
+        children: List<PageNode>
+    ): RootPageNode
 }
 
 class ModulePageNode(
@@ -28,9 +67,12 @@ class ModulePageNode(
     override val documentable: Documentable?,
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
-) : PageNode {
+) : RootPageNode(), ContentPage {
     override val dri: DRI = DRI.topLevel
 
+    override fun modified(name: String, children: List<PageNode>): ModulePageNode =
+        modified(name = name, content = this.content, children = children)
+
     override fun modified(
         name: String,
         content: ContentNode,
@@ -39,26 +81,6 @@ class ModulePageNode(
     ): ModulePageNode =
         if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
         else ModulePageNode(name, content, documentable, children, embeddedResources)
-
-    private fun PageNode.transformNode(operation: (PageNode) -> PageNode): PageNode =
-        operation(this).let { newNode ->
-            newNode.modified(children = newNode.children.map { it.transformNode(operation) })
-        }
-
-    fun transformPageNodeTree(operation: (PageNode) -> PageNode) =
-        this.transformNode(operation) as ModulePageNode
-
-    val parentMap: IdentityHashMap<PageNode, PageNode> by lazy {
-        IdentityHashMap<PageNode, PageNode>().apply {
-            fun addParent(parent: PageNode) {
-                parent.children.forEach {  child ->
-                    put(child, parent)
-                    addParent(child)
-                }
-            }
-            addParent(this@ModulePageNode)
-        }
-    }
 }
 
 class PackagePageNode(
@@ -69,7 +91,9 @@ class PackagePageNode(
     override val documentable: Documentable?,
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
-) : PageNode {
+) : ContentPage {
+    override fun modified(name: String, children: List<PageNode>): PackagePageNode =
+        modified(name = name, content = this.content, children = children)
 
     override fun modified(
         name: String,
@@ -88,7 +112,9 @@ class ClassPageNode(
     override val documentable: Documentable?,
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
-) : PageNode {
+) : ContentPage {
+    override fun modified(name: String, children: List<PageNode>): ClassPageNode =
+        modified(name = name, content = this.content, children = children)
 
     override fun modified(
         name: String,
@@ -107,7 +133,9 @@ class MemberPageNode(
     override val documentable: Documentable?,
     override val children: List<PageNode> = emptyList(),
     override val embeddedResources: List<String> = listOf()
-) : PageNode {
+) : ContentPage {
+    override fun modified(name: String, children: List<PageNode>): MemberPageNode =
+        modified(name = name, content = this.content, children = children)
 
     override fun modified(
         name: String,
@@ -129,10 +157,12 @@ fun PageNode.dfs(predicate: (PageNode) -> Boolean): PageNode? = if (predicate(th
     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 })
+fun PageNode.asSequence(): Sequence<PageNode> = sequence {
+    yield(this@asSequence)
+    children.asSequence().flatMap { it.asSequence() }.forEach { yield(it) }
+}
 
-// Navigation??
+inline fun <reified T: PageNode> PageNode.children() = children.filterIsInstance<T>()
 
-// content modifier?
-//data class ContentLink(val link: String): ContentNode
\ No newline at end of file
+private infix fun <T> List<T>.shallowEq(other: List<T>) =
+    this === other || (this.size == other.size && (this zip other).all { (a, b) -> a === b })
diff --git a/core/src/main/kotlin/pages/RendererSpecificPage.kt b/core/src/main/kotlin/pages/RendererSpecificPage.kt
new file mode 100644
index 00000000..85e6d530
--- /dev/null
+++ b/core/src/main/kotlin/pages/RendererSpecificPage.kt
@@ -0,0 +1,40 @@
+package org.jetbrains.dokka.pages
+
+import org.jetbrains.dokka.renderers.Renderer
+import kotlin.reflect.KClass
+
+interface RendererSpecificPage : PageNode {
+    val strategy: RenderingStrategy
+}
+
+class RendererSpecificRootPage(
+    override val name: String,
+    override val children: List<PageNode>,
+    override val strategy: RenderingStrategy
+) : RootPageNode(), RendererSpecificPage {
+    override fun modified(name: String, children: List<PageNode>): RendererSpecificRootPage =
+        RendererSpecificRootPage(name, children, strategy)
+}
+
+class RendererSpecificResourcePage(
+    override val name: String,
+    override val children: List<PageNode>,
+    override val strategy: RenderingStrategy
+): RendererSpecificPage {
+    override fun modified(name: String, children: List<PageNode>): RendererSpecificResourcePage =
+        RendererSpecificResourcePage(name, children, strategy)
+}
+
+sealed class RenderingStrategy {
+    class Callback(val instructions: Renderer.(PageNode) -> String): RenderingStrategy()
+    data class Copy(val from: String) : RenderingStrategy()
+    data class Write(val text: String) : RenderingStrategy()
+    object DoNothing : RenderingStrategy()
+
+    companion object {
+        inline operator fun <reified T: Renderer> invoke(crossinline instructions: T.(PageNode) -> String) =
+            Callback { if (this is T) instructions(it) else throw WrongRendererTypeException(T::class) }
+    }
+}
+
+data class WrongRendererTypeException(val expectedType: KClass<*>): Exception()
\ 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 5e3eadbe..606eea54 100644
--- a/core/src/main/kotlin/renderers/DefaultRenderer.kt
+++ b/core/src/main/kotlin/renderers/DefaultRenderer.kt
@@ -5,55 +5,62 @@ 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
 
 abstract class DefaultRenderer<T>(
     protected val outputWriter: OutputWriter,
     protected val context: DokkaContext
 ) : Renderer {
 
+    private val extension = context.single(CoreExtensions.fileExtension)
+
     protected lateinit var locationProvider: LocationProvider
         private set
 
+    protected open val preprocessors: Iterable<PageNodeTransformer> = emptyList()
+
     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)
+    protected abstract fun T.buildList(node: ContentList, pageContext: ContentPage)
     protected abstract fun T.buildNewLine()
-    protected abstract fun T.buildResource(node: ContentEmbeddedResource, pageContext: PageNode)
-    protected abstract fun T.buildTable(node: ContentTable, pageContext: PageNode)
+    protected abstract fun T.buildResource(node: ContentEmbeddedResource, pageContext: ContentPage)
+    protected abstract fun T.buildTable(node: ContentTable, pageContext: ContentPage)
     protected abstract fun T.buildText(textNode: ContentText)
     protected abstract fun T.buildNavigation(page: PageNode)
 
-    protected abstract fun buildPage(page: PageNode, content: (T, PageNode) -> Unit): String
+    protected abstract fun buildPage(page: ContentPage, content: (T, ContentPage) -> Unit): String
     protected abstract fun buildError(node: ContentNode)
 
-    protected open fun T.buildGroup(node: ContentGroup, pageContext: PageNode){
+    protected open fun T.buildGroup(node: ContentGroup, pageContext: ContentPage) {
         node.children.forEach { it.build(this, pageContext) }
     }
 
-    protected open fun T.buildLinkText(nodes: List<ContentNode>, pageContext: PageNode) {
+    protected open fun T.buildLinkText(nodes: List<ContentNode>, pageContext: ContentPage) {
         nodes.forEach { it.build(this, pageContext) }
     }
 
-    protected open fun T.buildCode(code: List<ContentNode>, language: String, pageContext: PageNode) {
+    protected open fun T.buildCode(code: List<ContentNode>, language: String, pageContext: ContentPage) {
         code.forEach { it.build(this, pageContext) }
     }
 
-    protected open fun T.buildHeader(node: ContentHeader, pageContext: PageNode) {
+    protected open fun T.buildHeader(node: ContentHeader, pageContext: ContentPage) {
         buildHeader(node.level) { node.children.forEach { it.build(this, pageContext) } }
     }
 
-    protected open fun ContentNode.build(builder: T, pageContext: PageNode) = builder.buildContentNode(this, pageContext)
+    protected open fun ContentNode.build(builder: T, pageContext: ContentPage) =
+        builder.buildContentNode(this, pageContext)
 
-    protected open fun T.buildContentNode(node: ContentNode, pageContext: PageNode) {
+    protected 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)) {
+                locationProvider.resolve(node.address, node.platforms.toList(), pageContext)
+            ) {
                 buildLinkText(node.children, pageContext)
             }
-            is ContentResolvedLink -> buildLink(node.address) {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)
@@ -62,22 +69,34 @@ abstract class DefaultRenderer<T>(
         }
     }
 
-    protected open fun buildPageContent(context: T, page: PageNode) {
+    protected open fun buildPageContent(context: T, page: ContentPage) {
         context.buildNavigation(page)
         page.content.build(context, page)
     }
 
-    protected open fun renderPage(page: PageNode) =
-        outputWriter.write(locationProvider.resolve(page), buildPage(page, ::buildPageContent), "")
+    protected 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 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))
+                RenderingStrategy.DoNothing -> Unit
+            }
+            else -> throw AssertionError(
+                "Page ${page.name} cannot be rendered by renderer as it is not renderer specific nor contains content"
+            )
+        }
+    }
 
     protected open fun renderPages(root: PageNode) {
         renderPage(root)
         root.children.forEach { renderPages(it) }
     }
 
-    protected open fun buildSupportFiles() {}
-
-    protected open fun renderPackageList(root: PageNode) =
+    // reimplement this as preprocessor
+    protected open fun renderPackageList(root: ContentPage) =
         getPackageNamesAndPlatforms(root)
             .keys
             .joinToString("\n")
@@ -93,12 +112,16 @@ abstract class DefaultRenderer<T>(
                     emptyMap()
                 }
 
-    override fun render(root: PageNode) {
-        locationProvider = context.single(CoreExtensions.locationProviderFactory).getLocationProvider(root as ModulePageNode)
-        renderPackageList(root)
-        buildSupportFiles()
-        renderPages(root)
+    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 PageNode.platforms() = this.content.platforms.toList()
\ No newline at end of file
+fun ContentPage.platforms() = this.content.platforms.toList()
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/FileWriter.kt b/core/src/main/kotlin/renderers/FileWriter.kt
index 22a2e8f9..2fba649d 100644
--- a/core/src/main/kotlin/renderers/FileWriter.kt
+++ b/core/src/main/kotlin/renderers/FileWriter.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka.renderers
 
-import com.intellij.util.io.isDirectory
 import java.io.File
 import java.io.IOException
 import java.net.URI
@@ -17,10 +16,9 @@ class FileWriter(val root: String, override val extension: String): OutputWriter
         createdFiles.add(path)
 
         try {
-//            println("Writing $root/$path$ext")
             val dir = Paths.get(root, path.dropLastWhile { it != '/' }).toFile()
             dir.mkdirsOrFail()
-            Paths.get(root, "$path$ext").toFile().writeText(text)
+            Files.write(Paths.get(root, "$path$ext"), text.lines())
         } catch (e: Throwable) {
             println("Failed to write $this. ${e.message}")
             e.printStackTrace()
@@ -36,7 +34,7 @@ class FileWriter(val root: String, override val extension: String): OutputWriter
         val fs = getFileSystemForURI(uri)
         val path = fs.getPath(pathFrom)
         for (file in Files.walk(path).iterator()) {
-            if (file.isDirectory()) {
+            if (Files.isDirectory(file)) {
                 val dirPath = file.toAbsolutePath().toString()
                 Paths.get(root, rebase(dirPath)).toFile().mkdirsOrFail()
             } else {
diff --git a/core/src/main/kotlin/renderers/HtmlRenderer.kt b/core/src/main/kotlin/renderers/HtmlRenderer.kt
index ae120795..af99d349 100644
--- a/core/src/main/kotlin/renderers/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/HtmlRenderer.kt
@@ -1,15 +1,12 @@
 package org.jetbrains.dokka.renderers
 
 import kotlinx.html.*
-import kotlinx.html.dom.document
-import kotlinx.html.stream.appendHTML
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.model.Documentable
+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.kotlin.utils.addToStdlib.ifNotEmpty
 import java.io.File
-import java.net.URL
 
 open class HtmlRenderer(
     outputWriter: OutputWriter,
@@ -39,7 +36,9 @@ open class HtmlRenderer(
         }
     }
 
-    override fun FlowContent.buildList(node: ContentList, pageContext: PageNode) =
+    override val preprocessors = listOf(RootCreator, SearchPageInstaller, ResourceInstaller, StyleAndScriptsAppender)
+
+    override fun FlowContent.buildList(node: ContentList, pageContext: ContentPage) =
         if (node.ordered) ol {
             buildListItems(node.children, pageContext)
         }
@@ -47,7 +46,7 @@ open class HtmlRenderer(
             buildListItems(node.children, pageContext)
         }
 
-    protected open fun OL.buildListItems(items: List<ContentNode>, pageContext: PageNode) {
+    protected open fun OL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
         items.forEach {
             if (it is ContentList)
                 buildList(it, pageContext)
@@ -56,7 +55,7 @@ open class HtmlRenderer(
         }
     }
 
-    protected open fun UL.buildListItems(items: List<ContentNode>, pageContext: PageNode) {
+    protected open fun UL.buildListItems(items: List<ContentNode>, pageContext: ContentPage) {
         items.forEach {
             if (it is ContentList)
                 buildList(it, pageContext)
@@ -67,7 +66,7 @@ open class HtmlRenderer(
 
     override fun FlowContent.buildResource(
         node: ContentEmbeddedResource,
-        pageContext: PageNode
+        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) {
@@ -79,7 +78,7 @@ open class HtmlRenderer(
         }
     }
 
-    override fun FlowContent.buildTable(node: ContentTable, pageContext: PageNode) {
+    override fun FlowContent.buildTable(node: ContentTable, pageContext: ContentPage) {
         table {
             thead {
                 node.header.forEach {
@@ -138,60 +137,48 @@ open class HtmlRenderer(
     override fun FlowContent.buildLink(address: String, content: FlowContent.() -> Unit) =
         a(href = address, block = content)
 
-    override fun FlowContent.buildCode(code: List<ContentNode>, language: String, pageContext: PageNode) {
+    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!"); ""} )
+            +((it as? ContentText)?.text ?: run { context.logger.error("Cannot cast $it as ContentText!"); "" })
             buildNewLine()
         }
     }
 
     override fun renderPage(page: PageNode) {
         super.renderPage(page)
-        pageList.add("""{ "name": "${page.name}", ${if (page is ClassPageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(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: PageNode) {
+    override fun render(root: RootPageNode) {
         super.render(root)
         outputWriter.write("scripts/pages", "var pages = [\n${pageList.joinToString(",\n")}\n]", ".js")
     }
 
-    override fun buildSupportFiles() { // TODO copy file instead of reading
-        outputWriter.write(
-            "style.css",
-            javaClass.getResourceAsStream("/dokka/styles/style.css").reader().readText()
-        )
-        renderPage(searchPageNode)
-        outputWriter.writeResources("/dokka/styles", "styles")
-        outputWriter.writeResources("/dokka/scripts", "scripts")
-        outputWriter.writeResources("/dokka/images", "images")
-    }
+    private fun PageNode.root(path: String) = locationProvider.resolveRoot(this) + path
 
-    private fun PageNode.root(path: String) =
-        "${if (this != searchPageNode) locationProvider.resolveRoot(this) else ""}$path"
+    override fun buildPage(page: ContentPage, content: (FlowContent, ContentPage) -> Unit): String =
+        buildHtml(page, page.embeddedResources) { content(this, page) }
 
-    override fun buildPage(page: PageNode, content: (FlowContent, PageNode) -> Unit): String =
-        StringBuilder().appendHTML().html {
-            document {
-
-            }
+    open fun buildHtml(page: PageNode, resources: List<String>, content: FlowContent.() -> Unit) =
+        createHTML().html {
             head {
                 title(page.name)
-                link(rel = LinkRel.stylesheet, href = page.root("styles/style.css"))
-                page.embeddedResources.filter {
-                    URL(it).path.substringAfterLast('.') == "js"
-                }.forEach {
-                    script(type = ScriptType.textJavaScript, src = it) { async = true }
-                }
-                if (page == searchPageNode) {
-                    script(
-                        type = ScriptType.textJavaScript,
-                        src = page.root("scripts/pages.js")
-                    ) { async = true }
+                with(resources) {
+                    filter { it.substringAfterLast('.') == "css" }
+                        .forEach { link(rel = LinkRel.stylesheet, href = page.root(it)) }
+                    filter { it.substringAfterLast('.') == "js" }
+                        .forEach { script(type = ScriptType.textJavaScript, src = it) { async = true } }
                 }
             }
             body {
@@ -207,65 +194,24 @@ open class HtmlRenderer(
                     }
                     div {
                         id = "sideMenu"
-                        img(src = page.root("images/logo-icon.svg"))
-                        img(src = page.root("images/logo-text.svg"))
-                        hr()
-                        input(type = InputType.search) {
-                            id = "navigationFilter"
-                        }
-                        script(
-                            type = ScriptType.textJavaScript,
-                            src = page.root("scripts/scripts.js")
-                        ) { async = true }
-                        buildSideMenu(page, locationProvider.top())
                     }
                 }
                 div {
                     id = "content"
-                    if (page != searchPageNode) content(this, page)
-                    else {
-                        h1 {
-                            id = "searchTitle"
-                            text("Search results for ")
-                        }
-                        table {
-                            tbody {
-                                id = "searchTable"
-                            }
-                        }
-                        script(
-                            type = ScriptType.textJavaScript,
-                            src = page.root("scripts/search.js")
-                        ) { async = true }
-                    }
+                    content()
                 }
             }
-        }.toString()
-
-    protected open fun List<HTMLMetadata>.joinAttr() = this.joinToString(" ") { it.key + "=" + it.value }
-
-    private val searchPageNode =
-        object: PageNode {
-            override val name: String
-                get() = "Search"
-            override val content = object: ContentNode{
-                override val dci: DCI = DCI(DRI.topLevel, ContentKind.Main)
-                override val platforms: Set<PlatformData> = emptySet()
-                override val style: Set<Style> = emptySet()
-                override val extras: Set<Extra> = emptySet()
-
-            }
-            override val dri: DRI = DRI.topLevel
-            override val documentable: Documentable? = null
-            override val embeddedResources: List<String> = emptyList()
-            override val children: List<PageNode> = emptyList()
+        }
+}
 
-            override fun modified(
-                name: String,
-                content: ContentNode,
-                embeddedResources: List<String>,
-                children: List<PageNode>
-            ): PageNode = this
+fun List<HTMLMetadata>.joinAttr() = joinToString(" ") { it.key + "=" + it.value }
 
-        }
-}
\ No newline at end of file
+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/Renderer.kt b/core/src/main/kotlin/renderers/Renderer.kt
index 271bdf77..10235f21 100644
--- a/core/src/main/kotlin/renderers/Renderer.kt
+++ b/core/src/main/kotlin/renderers/Renderer.kt
@@ -1,7 +1,7 @@
 package org.jetbrains.dokka.renderers
 
-import org.jetbrains.dokka.pages.PageNode
+import org.jetbrains.dokka.pages.RootPageNode
 
 interface Renderer {
-    fun render(root: PageNode)
+    fun render(root: RootPageNode)
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/renderers/htmlPreprocessors.kt b/core/src/main/kotlin/renderers/htmlPreprocessors.kt
new file mode 100644
index 00000000..a6ad267b
--- /dev/null
+++ b/core/src/main/kotlin/renderers/htmlPreprocessors.kt
@@ -0,0 +1,57 @@
+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"
+            )
+        )
+    }
+}
diff --git a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
index 8e848b63..48ea5316 100644
--- a/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
+++ b/core/src/main/kotlin/resolvers/DefaultLocationProvider.kt
@@ -8,19 +8,35 @@ import org.jetbrains.dokka.plugability.single
 import org.jetbrains.dokka.utilities.htmlEscape
 import java.util.*
 
+private const val PAGE_WITH_CHILDREN_SUFFIX = "index"
+
 open class DefaultLocationProvider(
-    private val pageGraphRoot: ModulePageNode,
-    private val dokkaContext: DokkaContext
-) : LocationProvider { // TODO: cache
-    private val extension = dokkaContext.single(CoreExtensions.fileExtension)
+    protected val pageGraphRoot: RootPageNode,
+    protected val dokkaContext: DokkaContext
+) : LocationProvider {
+    protected val extension = dokkaContext.single(CoreExtensions.fileExtension)
+
+    protected val pagesIndex: Map<DRI, ContentPage> = pageGraphRoot.asSequence().filterIsInstance<ContentPage>()
+        .groupingBy { it.dri }
+        .aggregate { dri, _, page, first ->
+            if (first) page else throw AssertionError("Multiple pages associated with dri: $dri")
+        }
 
-    private val pagesCache = mutableMapOf<DRI, Maybe<PageNode>>()
-    private val pathCache: MutableMap<PageNode, List<String>> = IdentityHashMap<PageNode, List<String>>()
+    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?): String = pathTo(node, context) + extension
+    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 =
-        findInPageGraph(dri, platforms)?.let { resolve(it, context) } ?:
+        pagesIndex[dri]?.let { resolve(it, context) } ?:
         // Not found in PageGraph, that means it's an external link
         ExternalLocationProvider.getLocation(dri,
             this.dokkaContext.configuration.passesConfigurations
@@ -31,50 +47,30 @@ open class DefaultLocationProvider(
                 .flatMap { it.externalDocumentationLinks }.distinct()
         )
 
-    override fun resolveRoot(node: PageNode): String = "../${pathTo(pageGraphRoot, node).removeSuffix(
-        PAGE_WITH_CHILDREN_SUFFIX
-    )}"
-
-    private fun PageNode.parent() = pageGraphRoot.parentMap[this]
-
-    override fun ancestors(node: PageNode?): List<PageNode> = when (node) {
-        null -> emptyList()
-        else -> ancestors(node.parent()) + node
-    }
-
-    override fun top(): PageNode = pageGraphRoot
-
-    protected open fun findInPageGraph(dri: DRI, platforms: List<PlatformData>): PageNode? =
-        pagesCache.getOrPut(dri) { pageGraphRoot.dfs { it.dri == dri }.wrapped }.unwrapped
+    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 PageNode.pathName(): String =
-            if (this is PackagePageNode) name
-            else identifierToFilename(name)
-
-        fun getPathInternal(pathNode: PageNode?, path: List<String>): List<String> = when (pathNode) {
-            null -> path
-            else -> getPathInternal(pathNode.parent(), path + pathNode.pathName().ifEmpty { "root" })
-        }
-
-        fun getPath(pathNode: PageNode) = pathCache.getOrPut(pathNode) { getPathInternal(pathNode, emptyList()) }
+        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 = getPath(node).reversed()
-        val contextPath = contextNode?.let(::getPath).orEmpty().reversed()
+        val nodePath = pathFor(node)
+        val contextPath = contextNode?.let { pathFor(it) }.orEmpty()
 
-        val commonPathElements = nodePath.zip(contextPath).takeWhile { (a, b) -> a == b }.size
+        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 companion object {
-        const val PAGE_WITH_CHILDREN_SUFFIX = "index"
-    }
+    private fun PageNode.parent() = pageGraphRoot.parentMap[this]
 }
 
 fun DRI.toJavadocLocation(jdkVersion: Int): String { // TODO: classes without packages?
@@ -122,6 +118,5 @@ private fun identifierToFilename(name: String): String {
     return if (lowercase in reservedFilenames) "--$lowercase--" else lowercase
 }
 
-private class Maybe<T : Any>(val unwrapped: T?)
-
-private val <T : Any> T?.wrapped: Maybe<T> get() = Maybe(this)
\ No newline at end of file
+private val PageNode.pathName: String
+    get() = if (this is PackagePageNode) name else identifierToFilename(name)
diff --git a/core/src/main/kotlin/resolvers/LocationProvider.kt b/core/src/main/kotlin/resolvers/LocationProvider.kt
index 7d77ccb8..3bc9ab72 100644
--- a/core/src/main/kotlin/resolvers/LocationProvider.kt
+++ b/core/src/main/kotlin/resolvers/LocationProvider.kt
@@ -1,13 +1,13 @@
 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): String
+    fun resolve(node: PageNode, context: PageNode? = null, skipExtension: Boolean = false): String
     fun resolveRoot(node: PageNode): String
-    fun ancestors(node: PageNode?): List<PageNode>
-    fun top(): PageNode
+    fun ancestors(node: PageNode): List<PageNode>
 }
diff --git a/core/src/main/kotlin/resolvers/LocationProviderFactory.kt b/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
index c657846a..782795de 100644
--- a/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
+++ b/core/src/main/kotlin/resolvers/LocationProviderFactory.kt
@@ -1,13 +1,14 @@
 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: ModulePageNode): LocationProvider
+    fun getLocationProvider(pageNode: RootPageNode): LocationProvider
 }
 
 class DefaultLocationProviderFactory(val context: DokkaContext) : LocationProviderFactory {
 
-    override fun getLocationProvider(pageNode: ModulePageNode)  = DefaultLocationProvider(pageNode, context)
+    override fun getLocationProvider(pageNode: RootPageNode)  = DefaultLocationProvider(pageNode, context)
 }
\ 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
index a2867504..cac9d44c 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
@@ -1,6 +1,5 @@
 package org.jetbrains.dokka.transformers.documentation
 
-import com.intellij.openapi.diagnostic.logger
 import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.plugability.DokkaContext
diff --git a/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt b/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
index 286835f9..45357060 100644
--- a/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
+++ b/core/src/main/kotlin/transformers/pages/PageNodeTransformer.kt
@@ -1,8 +1,9 @@
 package org.jetbrains.dokka.transformers.pages
 
 import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 
 interface PageNodeTransformer {
-    operator fun invoke(input: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode
+    operator fun invoke(input: RootPageNode): RootPageNode
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/utilities/nodeDebug.kt b/core/src/main/kotlin/utilities/nodeDebug.kt
index 984f13ed..0e8c61f7 100644
--- a/core/src/main/kotlin/utilities/nodeDebug.kt
+++ b/core/src/main/kotlin/utilities/nodeDebug.kt
@@ -34,7 +34,7 @@ fun Documentable.pretty(prefix: String = "", isLast: Boolean = true): String {
 //}
 private fun Any.stringify() = when(this) {
     is ContentNode -> toString() + this.dci
-    is PageNode -> this.name + this::class.simpleName
+    is ContentPage -> this.name + this::class.simpleName
     else -> toString()
 }
 //private fun Any.allChildren() = when(this){
diff --git a/core/src/main/resources/dokka/scripts/navigationLoader.js b/core/src/main/resources/dokka/scripts/navigationLoader.js
new file mode 100644
index 00000000..e69de29b
diff --git a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
index 32294ea8..52723157 100644
--- a/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
+++ b/plugins/mathjax/src/main/kotlin/MathjaxPlugin.kt
@@ -3,9 +3,9 @@ package  org.jetbrains.dokka.mathjax
 
 import org.jetbrains.dokka.model.doc.CustomWrapperTag
 import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.pages.ModulePageNode
+import org.jetbrains.dokka.pages.ContentPage
 import org.jetbrains.dokka.pages.PageNode
-import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
@@ -19,17 +19,13 @@ 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) }
-    )
-
+    override fun invoke(input: RootPageNode) = input.transformContentPagesTree {
+        it.modified(
+            embeddedResources = it.embeddedResources + if (it.isNeedingMathjax) listOf(LIB_PATH) else emptyList()
+        )
+    }
 
-    private val PageNode.isNeedingMathjax
+    private val ContentPage.isNeedingMathjax
         get() = documentable?.platformInfo
             ?.flatMap { it.documentationNode.children }
             .orEmpty()
diff --git a/plugins/xml/src/main/kotlin/XmlPlugin.kt b/plugins/xml/src/main/kotlin/XmlPlugin.kt
index 839929e6..998a56ea 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -12,48 +12,52 @@ import org.jetbrains.dokka.transformers.pages.PageNodeTransformer
 
 class XmlPlugin : DokkaPlugin() {
     val transformer by extending {
-        CoreExtensions.pageTransformer with XmlTransformer
+        CoreExtensions.pageTransformer providing ::XmlTransformer
     }
 }
 
-object XmlTransformer : PageNodeTransformer {
+class XmlTransformer(private val dokkaContext: DokkaContext) : PageNodeTransformer {
+    private val commentsToContentConverter by lazy { dokkaContext.single(CoreExtensions.commentsToContentConverter) }
+
     enum class XMLKind : Kind {
         Main, XmlList
     }
 
-    override fun invoke(input: ModulePageNode, dokkaContext: DokkaContext): ModulePageNode =
-        input.transformPageNodeTree { node ->
-            if (node !is ClassPageNode) node
-            else {
-                val refs =
-                    node.documentable?.extra?.filterIsInstance<XMLMega>()?.filter { it.key == "@attr ref" }
-                        .orEmpty()
-                val elementsToAdd = mutableListOf<Documentable>()
-
-                refs.forEach { ref ->
-                    input.documentable?.dfs { it.dri == ref.dri }?.let { elementsToAdd.add(it) }
-                }
-                val platformData = node.platforms().toSet()
-                val refTable = DefaultPageContentBuilder.group(
-                    node.dri,
-                    platformData,
-                    XMLKind.XmlList,
-                    dokkaContext.single(CoreExtensions.commentsToContentConverter),
-                    dokkaContext.logger
-                ) {
-                    block("XML Attributes", 2, XMLKind.XmlList, elementsToAdd, platformData) { element ->
-                        link(element.dri, XMLKind.XmlList) {
-                            text(element.name ?: "<unnamed>", XMLKind.Main)
-                        }
-                        text(element.briefDocTagString, XMLKind.XmlList)
+    override fun invoke(input: RootPageNode): RootPageNode =
+        input.transformPageNodeTree { if (it is ModulePageNode) transformModule(it) else it }
+
+    private fun transformModule(module: ModulePageNode) = module.transformContentPagesTree { node ->
+        if (node !is ClassPageNode) node
+        else {
+            val refs =
+                node.documentable?.extra?.filterIsInstance<XMLMega>()?.filter { it.key == "@attr ref" }
+                    .orEmpty()
+            val elementsToAdd = mutableListOf<Documentable>()
+
+            refs.forEach { ref ->
+                module.documentable?.dfs { it.dri == ref.dri }?.let { elementsToAdd.add(it) }
+            }
+            val platformData = node.platforms().toSet()
+            val refTable = DefaultPageContentBuilder.group(
+                node.dri,
+                platformData,
+                XMLKind.XmlList,
+                commentsToContentConverter,
+                dokkaContext.logger
+            ) {
+                block("XML Attributes", 2, XMLKind.XmlList, elementsToAdd, platformData) { element ->
+                    link(element.dri, XMLKind.XmlList) {
+                        text(element.name ?: "<unnamed>", XMLKind.Main)
                     }
+                    text(element.briefDocTagString, XMLKind.XmlList)
                 }
-
-                val content = node.content as ContentGroup
-                val children = (node.content as ContentGroup).children
-                node.modified(content = content.copy(children = children + refTable))
             }
+
+            val content = node.content as ContentGroup
+            val children = (node.content as ContentGroup).children
+            node.modified(content = content.copy(children = children + refTable))
         }
+    }
 
-    private fun PageNode.platforms() = this.content.platforms.toList()
+    private fun ContentPage.platforms() = this.content.platforms.toList()
 }
\ 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 fdc2d0f7..fa61bf59 100644
--- a/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
+++ b/testApi/src/main/kotlin/testApi/testRunner/TestRunner.kt
@@ -4,6 +4,7 @@ import org.jetbrains.dokka.*
 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.utilities.DokkaConsoleLogger
 import org.junit.rules.TemporaryFolder
@@ -93,7 +94,7 @@ abstract class AbstractCoreTest {
         var documentablesMergingStage: (Module) -> Unit = {}
         var documentablesTransformationStage: (Module) -> Unit = {}
         var pagesGenerationStage: (ModulePageNode) -> Unit = {}
-        var pagesTransformationStage: (ModulePageNode) -> Unit = {}
+        var pagesTransformationStage: (RootPageNode) -> Unit = {}
 
         fun build() = TestMethods(
             analysisSetupStage,
@@ -203,5 +204,5 @@ data class TestMethods(
     val documentablesMergingStage: (Module) -> Unit,
     val documentablesTransformationStage: (Module) -> Unit,
     val pagesGenerationStage: (ModulePageNode) -> Unit,
-    val pagesTransformationStage: (ModulePageNode) -> Unit
+    val pagesTransformationStage: (RootPageNode) -> Unit
 )
\ No newline at end of file
-- 
cgit 


From 612e8c2f6f1b52f19c6ae51aa3d5655dfb43ba0c Mon Sep 17 00:00:00 2001
From: Szymon Świstun <sswistun@virtuslab.com>
Date: Thu, 23 Jan 2020 11:10:37 +0100
Subject: formatting

---
 .idea/codeStyles/Project.xml                       |  18 +---
 .idea/compiler.xml                                 |   4 +
 .idea/jarRepositories.xml                          |   5 +
 core/src/main/kotlin/model/Documentable.kt         | 120 +++++++++++++++++----
 core/src/main/kotlin/pages/PageBuilder.kt          |  64 +++++++++--
 core/src/main/kotlin/pages/PageContentBuilder.kt   |  17 ++-
 core/src/main/kotlin/pages/PageNodes.kt            |  10 +-
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |   4 +-
 .../DefaultDescriptorToDocumentationTranslator.kt  |  61 ++++++++---
 .../DefaultDocumentationNodeMerger.kt              |  59 ++++++----
 plugins/xml/src/main/kotlin/XmlPlugin.kt           |   2 +-
 11 files changed, 269 insertions(+), 95 deletions(-)

(limited to 'plugins/xml/src')

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index ba49a93e..1bec35e5 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,24 +1,10 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
     <JetCodeStyleSettings>
-      <option name="CONTINUATION_INDENT_IN_PARAMETER_LISTS" value="false" />
-      <option name="CONTINUATION_INDENT_IN_ARGUMENT_LISTS" value="false" />
-      <option name="CONTINUATION_INDENT_FOR_EXPRESSION_BODIES" value="false" />
-      <option name="CONTINUATION_INDENT_FOR_CHAINED_CALLS" value="false" />
-      <option name="CONTINUATION_INDENT_IN_SUPERTYPE_LISTS" value="false" />
-      <option name="CONTINUATION_INDENT_IN_IF_CONDITIONS" value="false" />
-      <option name="WRAP_EXPRESSION_BODY_FUNCTIONS" value="1" />
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
     <codeStyleSettings language="kotlin">
-      <option name="CALL_PARAMETERS_WRAP" value="5" />
-      <option name="CALL_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
-      <option name="CALL_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
-      <option name="METHOD_PARAMETERS_WRAP" value="5" />
-      <option name="METHOD_PARAMETERS_LPAREN_ON_NEXT_LINE" value="true" />
-      <option name="METHOD_PARAMETERS_RPAREN_ON_NEXT_LINE" value="true" />
-      <option name="EXTENDS_LIST_WRAP" value="1" />
-      <option name="METHOD_CALL_CHAIN_WRAP" value="1" />
-      <option name="ASSIGNMENT_WRAP" value="1" />
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </codeStyleSettings>
   </code_scheme>
 </component>
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index feb731d8..797b1d01 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -32,6 +32,8 @@
       <module name="dokka.coreDependencies.test" target="1.8" />
       <module name="dokka.integration-tests.gradle-integration-tests.main" target="1.8" />
       <module name="dokka.integration-tests.gradle-integration-tests.test" target="1.8" />
+      <module name="dokka.integration-tests.main" target="1.8" />
+      <module name="dokka.integration-tests.test" target="1.8" />
       <module name="dokka.integration.main" target="1.8" />
       <module name="dokka.integration.test" target="1.8" />
       <module name="dokka.plugins.javadoc8.main" target="1.8" />
@@ -56,8 +58,10 @@
       <module name="dokka.runners.gradle-integration-tests.test" target="1.8" />
       <module name="dokka.runners.gradle-plugin.main" target="1.8" />
       <module name="dokka.runners.gradle-plugin.test" target="1.8" />
+      <module name="dokka.runners.main" target="1.8" />
       <module name="dokka.runners.maven-plugin.main" target="1.8" />
       <module name="dokka.runners.maven-plugin.test" target="1.8" />
+      <module name="dokka.runners.test" target="1.8" />
       <module name="dokka.testApi.main" target="1.8" />
       <module name="dokka.testApi.test" target="1.8" />
       <module name="fatjar_main" target="1.8" />
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index b5925b37..915691dd 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -86,5 +86,10 @@
       <option name="name" value="maven6" />
       <option name="url" value="https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/1.3.61/maven" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven" />
+      <option name="name" value="maven" />
+      <option name="url" value="https://dl.bintray.com/jetbrains/markdown/" />
+    </remote-repository>
   </component>
 </project>
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index 7add2c3f..86ba24b7 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -1,9 +1,10 @@
 package org.jetbrains.dokka.model
 
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.transformers.descriptors.KotlinTypeWrapper
 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.dokka.transformers.descriptors.KotlinTypeWrapper
 
 class Module(override val name: String, val packages: List<Package>) : Documentable() {
     override val dri: DRI = DRI.topLevel
@@ -15,7 +16,7 @@ class Package(
     override val dri: DRI,
     override val functions: List<Function>,
     override val properties: List<Property>,
-    override val classes: List<Class>,
+    override val classlikes: List<Classlike>,
     override val extra: MutableSet<Extra> = mutableSetOf()
 ) : ScopeNode() {
     override val name = dri.packageName.orEmpty()
@@ -24,16 +25,79 @@ class Package(
 class Class(
     override val dri: DRI,
     override val name: String,
-    val kind: ClassKind,
+    override val kind: ClassKind,
     val constructors: List<Function>,
     override val functions: List<Function>,
     override val properties: List<Property>,
-    override val classes: List<Class>,
+    override val classlikes: List<Classlike>,
     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() }
+) : Classlike(
+    name = name,
+    dri = dri,
+    kind = kind,
+    functions = functions,
+    properties = properties,
+    classlikes = classlikes,
+    expected = expected,
+    actual = actual,
+    extra = extra
+)
+
+class Enum(
+    override val dri: DRI,
+    override val name: String,
+    val entries: List<EnumEntry>,
+    val constructors: List<Function>,
+    override val functions: List<Function> = emptyList(),
+    override val properties: List<Property> = emptyList(),
+    override val classlikes: List<Classlike> = emptyList(),
+    override val expected: ClassPlatformInfo? = null,
+    override val actual: List<ClassPlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : Classlike(dri = dri, name = name, kind = KotlinClassKindTypes.ENUM_CLASS, actual = actual) {
+    constructor(c: Classlike, entries: List<EnumEntry>, ctors: List<Function>) : this(
+        dri = c.dri,
+        name = c.name,
+        entries = entries,
+        constructors = ctors,
+        functions = c.functions,
+        properties = c.properties,
+        classlikes = c.classlikes,
+        expected = c.expected,
+        actual = c.actual,
+        extra = c.extra
+    )
+
+    override val children: List<Documentable>
+        get() = entries
+}
+
+class EnumEntry(
+    override val dri: DRI,
+    override val name: String,
+    override val expected: ClassPlatformInfo? = null,
+    override val actual: List<ClassPlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : Classlike(
+    dri = dri,
+    name = name,
+    actual = actual,
+    expected = expected,
+    extra = extra,
+    kind = KotlinClassKindTypes.ENUM_ENTRY
+) {
+    constructor(c: Classlike) : this(
+        dri = c.dri,
+        name = c.name,
+        actual = c.actual,
+        expected = c.expected,
+        extra = c.extra
+    )
+
+    override val children: List<Parameter>
+        get() = emptyList()
 }
 
 class Function(
@@ -83,7 +147,8 @@ interface PlatformInfo {
 
 class BasePlatformInfo(
     override val documentationNode: DocumentationNode,
-    override val platformData: List<PlatformData>) : PlatformInfo {
+    override val platformData: List<PlatformData>
+) : PlatformInfo {
 
     override fun equals(other: Any?): Boolean =
         other is PlatformInfo && documentationNode == other.documentationNode
@@ -94,7 +159,8 @@ class BasePlatformInfo(
 
 class ClassPlatformInfo(
     val info: PlatformInfo,
-    val inherited: List<DRI>) : PlatformInfo by info
+    val inherited: List<DRI>
+) : PlatformInfo by info
 
 abstract class Documentable {
     open val expected: PlatformInfo? = null
@@ -114,27 +180,45 @@ abstract class Documentable {
 
     override fun hashCode() = dri.hashCode()
 
+
+    val commentsData: List<DocumentationNode>
+        get() = platformInfo.map { it.documentationNode }
+
     val briefDocTagString: String
         get() =
             platformInfo
-            .firstOrNull()
-            ?.documentationNode
-            ?.children
-            ?.firstOrNull()
-            ?.root
-            ?.docTagSummary()
-            ?.shorten(40) ?: ""
+                .firstOrNull()
+                ?.documentationNode
+                ?.children
+                ?.firstOrNull()
+                ?.root
+                ?.docTagSummary()
+                ?.shorten(40) ?: ""
 
     open val extra: MutableSet<Extra> = mutableSetOf()
 }
 
+abstract class Classlike(
+    override val dri: DRI,
+    override val name: String,
+    open val kind: ClassKind,
+    override val functions: List<Function> = emptyList(),
+    override val properties: List<Property> = emptyList(),
+    override val classlikes: List<Classlike> = emptyList(),
+    override val expected: ClassPlatformInfo? = null,
+    override val actual: List<ClassPlatformInfo>,
+    override val extra: MutableSet<Extra> = mutableSetOf()
+) : ScopeNode() {
+    val inherited by lazy { platformInfo.mapNotNull { (it as? ClassPlatformInfo)?.inherited }.flatten() }
+}
+
 abstract class ScopeNode : Documentable() {
     abstract val functions: List<Function>
     abstract val properties: List<Property>
-    abstract val classes: List<Class>
+    abstract val classlikes: List<Classlike>
 
     override val children: List<Documentable>
-        get() = functions + properties + classes
+        get() = functions + properties + classlikes
 }
 
 abstract class CallableNode : Documentable() {
diff --git a/core/src/main/kotlin/pages/PageBuilder.kt b/core/src/main/kotlin/pages/PageBuilder.kt
index e8930fae..003cc815 100644
--- a/core/src/main/kotlin/pages/PageBuilder.kt
+++ b/core/src/main/kotlin/pages/PageBuilder.kt
@@ -1,8 +1,9 @@
 package org.jetbrains.dokka.pages
 
-import org.jetbrains.dokka.model.doc.TagWrapper
 import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Enum
 import org.jetbrains.dokka.model.Function
+import org.jetbrains.dokka.model.doc.TagWrapper
 
 class DefaultPageBuilder(
     override val rootContentGroup: RootContentBuilder
@@ -13,14 +14,21 @@ class DefaultPageBuilder(
 
     override fun pageForPackage(p: Package) =
         PackagePageNode(p.name, contentForPackage(p), setOf(p.dri), p,
-            p.classes.map { pageForClass(it) } +
+            p.classlikes.map { pageForClasslike(it) } +
                     p.functions.map { pageForMember(it) })
 
-    override fun pageForClass(c: Class): ClassPageNode =
-        ClassPageNode(c.name, contentForClass(c), setOf(c.dri), c,
-            c.constructors.map { pageForMember(it) } +
-                    c.classes.map { pageForClass(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) {
@@ -43,7 +51,7 @@ class DefaultPageBuilder(
 
     private fun contentForPackage(p: Package) = group(p) {
         header(1) { text("Package ${p.name}") }
-        block("Types", 2, ContentKind.Properties, p.classes, p.platformData) {
+        block("Types", 2, ContentKind.Properties, p.classlikes, p.platformData) {
             link(it.name, it.dri)
             text(it.briefDocTagString)
         }
@@ -54,6 +62,12 @@ class DefaultPageBuilder(
         }
     }
 
+    private fun contentForClasslike(c: Classlike): ContentGroup = when (c) {
+        is Class -> contentForClass(c)
+        is Enum -> contentForEnum(c)
+        else -> throw IllegalStateException("$c should not be present here")
+    }
+
     private fun contentForClass(c: Class) = group(c) {
         header(1) { text(c.name) }
         c.inherited.takeIf { it.isNotEmpty() }?.let {
@@ -69,7 +83,32 @@ class DefaultPageBuilder(
                 comment(it.root)
                 text("\n")
             }
+
+            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)
@@ -86,6 +125,15 @@ class DefaultPageBuilder(
         }
     }
 
+    private fun PageContentBuilder.contentForComments(d: Documentable) =
+        d.commentsData.forEach {
+            it.children.forEach {
+                header(3) { text(it.toHeaderString()) }
+                comment(it.root)
+                text("\n")
+            }
+        }
+
     private fun contentForFunction(f: Function) = group(f) {
         header(1) { text(f.name) }
         signature(f)
@@ -115,5 +163,5 @@ interface PageBuilder {
     fun pageForModule(m: Module): ModulePageNode
     fun pageForPackage(p: Package): PackagePageNode
     fun pageForMember(m: CallableNode): MemberPageNode
-    fun pageForClass(c: Class): ClassPageNode
+    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
index efe23b5a..d5ffe27a 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.model.doc.DocTag
-import org.jetbrains.dokka.utilities.DokkaLogger
+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.links.DRI
+import org.jetbrains.dokka.model.doc.DocTag
+import org.jetbrains.dokka.utilities.DokkaLogger
 
 class DefaultPageContentBuilder(
     private val dri: Set<DRI>,
@@ -169,10 +169,9 @@ private fun PageContentBuilder.type(t: TypeWrapper) {
     else if (t.constructorNamePathSegments.isNotEmpty() && t.dri == null)
         text(t.toString())
     else (this as? DefaultPageContentBuilder)?.let {
-            logger.error("type $t cannot be resolved")
-            text("???")
-        }
-
+        logger.error("type $t cannot be resolved")
+        text("???")
+    }
     list(t.arguments, prefix = "<", suffix = ">") {
         type(it)
     }
@@ -199,8 +198,8 @@ interface PageContentBuilder {
     fun header(level: Int, block: PageContentBuilderFunction)
     fun <T> list(
         elements: List<T>,
-        prefix: String =  "",
-        suffix: String =  "",
+        prefix: String = "",
+        suffix: String = "",
         separator: String = ",",
         operation: PageContentBuilder.(T) -> Unit
     )
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index 73d63cd7..6b67a734 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -47,7 +47,7 @@ abstract class RootPageNode: PageNode {
 
     fun transformContentPagesTree(operation: (ContentPage) -> ContentPage) = transformPageNodeTree {
         if (it is ContentPage) operation(it) else it
-    } as RootPageNode
+    }
 
     private fun PageNode.transformNode(operation: (PageNode) -> PageNode): PageNode =
         operation(this).let { newNode ->
@@ -105,7 +105,7 @@ class PackagePageNode(
         else PackagePageNode(name, content, dri, documentable, children, embeddedResources)
 }
 
-class ClassPageNode(
+class ClasslikePageNode(
     override val name: String,
     override val content: ContentNode,
     override val dri: Set<DRI>,
@@ -113,7 +113,7 @@ class ClassPageNode(
     override val children: List<PageNode>,
     override val embeddedResources: List<String> = listOf()
 ) : ContentPage {
-    override fun modified(name: String, children: List<PageNode>): ClassPageNode =
+    override fun modified(name: String, children: List<PageNode>): ClasslikePageNode =
         modified(name = name, content = this.content, children = children)
 
     override fun modified(
@@ -121,9 +121,9 @@ class ClassPageNode(
         content: ContentNode,
         embeddedResources: List<String>,
         children: List<PageNode>
-    ): ClassPageNode =
+    ): ClasslikePageNode =
         if (name == this.name && content === this.content && embeddedResources === this.embeddedResources && children shallowEq this.children) this
-        else ClassPageNode(name, content, dri, documentable, children, embeddedResources)
+        else ClasslikePageNode(name, content, dri, documentable, children, embeddedResources)
 }
 
 class MemberPageNode(
diff --git a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 27197ce6..47f5d066 100644
--- a/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/core/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -145,7 +145,7 @@ open class HtmlRenderer(
         super.renderPage(page)
         if (page is ContentPage) {
             pageList.add(
-                """{ "name": "${page.name}", ${if (page is ClassPageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(
+                """{ "name": "${page.name}", ${if (page is ClasslikePageNode) "\"class\": \"${page.name}\"," else ""} "location": "${locationProvider.resolve(
                     page
                 )}" }"""
             )
@@ -205,7 +205,7 @@ fun List<HTMLMetadata>.joinAttr() = joinToString(" ") { it.key + "=" + it.value
 
 private fun PageNode.pageKind() = when (this) {
     is PackagePageNode -> "package"
-    is ClassPageNode -> "class"
+    is ClasslikePageNode -> "class"
     is MemberPageNode -> when (this.documentable) {
         is Function -> "function"
         else -> "other"
diff --git a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
index 54762303..651bd223 100644
--- a/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
+++ b/core/src/main/kotlin/transformers/descriptors/DefaultDescriptorToDocumentationTranslator.kt
@@ -1,15 +1,17 @@
 package org.jetbrains.dokka.transformers.descriptors
 
 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
+import org.jetbrains.dokka.model.*
+import org.jetbrains.dokka.model.Enum
+import org.jetbrains.dokka.model.Function
 import org.jetbrains.dokka.model.Property
+import org.jetbrains.dokka.model.ClassKind
 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
@@ -20,10 +22,9 @@ 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 org.jetbrains.dokka.parsers.MarkdownParser
 import kotlin.reflect.KClass
 
-object DefaultDescriptorToDocumentationTranslator: DescriptorToDocumentationTranslator {
+object DefaultDescriptorToDocumentationTranslator : DescriptorToDocumentationTranslator {
     override fun invoke(
         moduleName: String,
         packageFragments: Iterable<PackageFragmentDescriptor>,
@@ -42,6 +43,8 @@ internal data class DRIWithPlatformInfo(
     val actual: List<PlatformInfo>
 )
 
+private fun DRI.withEmptyInfo() = DRIWithPlatformInfo(this, null, emptyList())
+
 internal class DokkaDescriptorVisitor(
     private val platformData: PlatformData,
     private val resolutionFacade: DokkaResolutionFacade
@@ -54,18 +57,42 @@ internal class DokkaDescriptorVisitor(
         descriptor: PackageFragmentDescriptor,
         parent: DRIWithPlatformInfo
     ): Package {
-        val driWithPlatform = DRIWithPlatformInfo(DRI(packageName = descriptor.fqName.asString()), null, emptyList())
+        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),
-            classes = scope.classes(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.getMemberScope(emptyList())
+        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()
         )
     }
 
-    override fun visitClassDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Class {
-        val driWithPlatform = DRIWithPlatformInfo(parent.dri.withClass(descriptor.name.asString()), null, emptyList())
+    fun classDescriptor(descriptor: ClassDescriptor, parent: DRIWithPlatformInfo): Class {
+        val driWithPlatform = parent.dri.withClass(descriptor.name.asString()).withEmptyInfo()
         val scope = descriptor.getMemberScope(emptyList())
         val descriptorData = descriptor.takeUnless { it.isExpect }?.resolveClassDescriptionData()
         val expected = descriptor.takeIf { it.isExpect }?.resolveClassDescriptionData()
@@ -87,7 +114,7 @@ internal class DokkaDescriptorVisitor(
             ) },
             functions = scope.functions(driWithPlatform),
             properties = scope.properties(driWithPlatform),
-            classes = scope.classes(driWithPlatform),
+            classlikes = scope.classlikes(driWithPlatform),
             expected = expected,
             actual = actual,
             extra = mutableSetOf() // TODO Implement following method to return proper results getXMLDRIs(descriptor, descriptorData).toMutableSet()
@@ -193,7 +220,7 @@ internal class DokkaDescriptorVisitor(
             .filterIsInstance<PropertyDescriptor>()
             .map { visitPropertyDescriptor(it, parent) }
 
-    private fun MemberScope.classes(parent: DRIWithPlatformInfo): List<Class> =
+    private fun MemberScope.classlikes(parent: DRIWithPlatformInfo): List<Classlike> =
         getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS) { true }
             .filterIsInstance<ClassDescriptor>()
             .map { visitClassDescriptor(it, parent) }
@@ -242,10 +269,12 @@ class KotlinTypeWrapper(private val kotlinType: KotlinType) : TypeWrapper {
     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 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/documentation/DefaultDocumentationNodeMerger.kt b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
index 86348206..ec67ea88 100644
--- a/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
+++ b/core/src/main/kotlin/transformers/documentation/DefaultDocumentationNodeMerger.kt
@@ -1,6 +1,7 @@
 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
 
@@ -18,9 +19,9 @@ internal object DefaultDocumentationNodeMerger : DocumentationNodeMerger {
     }
 }
 
-private fun <T: Documentable> 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)}
+        .reduce { _, left, right -> reducer(left, right) }
         .values.toList()
 
 fun PlatformInfo.mergeWith(other: PlatformInfo?) = BasePlatformInfo(
@@ -33,17 +34,17 @@ fun ClassPlatformInfo.mergeWith(other: ClassPlatformInfo?) = ClassPlatformInfo(
     (inherited + (other?.inherited ?: emptyList())).distinct()
 )
 
-fun List<ClassPlatformInfo>.mergeClassPlatformInfo() : List<ClassPlatformInfo> =
-    groupingBy { it.documentationNode.children + it.inherited}.reduce {
-            _, left, right -> left.mergeWith(right)
+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)
+fun List<PlatformInfo>.merge(): List<PlatformInfo> =
+    groupingBy { it.documentationNode }.reduce { _, left, right ->
+        left.mergeWith(right)
     }.values.toList()
 
-fun Function.mergeWith(other: Function) = Function(
+fun Function.mergeWith(other: Function): Function = Function(
     dri,
     name,
     returnType,
@@ -62,16 +63,34 @@ fun Property.mergeWith(other: Property) = Property(
     (actual + other.actual).merge()
 )
 
+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,
-    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()
+    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()
+)
+
+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)
 )
 
 fun Parameter.mergeWith(other: Parameter) = Parameter(
@@ -82,9 +101,9 @@ fun Parameter.mergeWith(other: Parameter) = Parameter(
     (actual + other.actual).merge()
 )
 
-fun Package.mergeWith(other: Package) = Package(
+fun Package.mergeWith(other: Package): Package = Package(
     dri,
     merge(functions + other.functions, Function::mergeWith),
     merge(properties + other.properties, Property::mergeWith),
-    merge(classes + other.classes, Class::mergeWith)
+    merge(classlikes + other.classlikes, Classlike::mergeWith)
 )
\ 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 998a56ea..e19b76b3 100644
--- a/plugins/xml/src/main/kotlin/XmlPlugin.kt
+++ b/plugins/xml/src/main/kotlin/XmlPlugin.kt
@@ -27,7 +27,7 @@ class XmlTransformer(private val dokkaContext: DokkaContext) : PageNodeTransform
         input.transformPageNodeTree { if (it is ModulePageNode) transformModule(it) else it }
 
     private fun transformModule(module: ModulePageNode) = module.transformContentPagesTree { node ->
-        if (node !is ClassPageNode) node
+        if (node !is ClasslikePageNode) node
         else {
             val refs =
                 node.documentable?.extra?.filterIsInstance<XMLMega>()?.filter { it.key == "@attr ref" }
-- 
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 'plugins/xml/src')

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 'plugins/xml/src')

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