From 8c218ff4dd5f970233c43845c19299fc74256389 Mon Sep 17 00:00:00 2001
From: Ignat Beresnev <ignat.beresnev@jetbrains.com>
Date: Fri, 29 Apr 2022 15:03:08 +0300
Subject: Enable warnings as errors and fix all warnings (#2451)

* Enable warnings as errors and fix all warnings

* Enable skip-metadata-version-check compiler setting
---
 .../utils/assertHtmlEqualsIgnoringWhitespace.kt    |   2 +-
 .../base/src/main/kotlin/parsers/MarkdownParser.kt |   4 +-
 .../factories/DocTagsFromIElementFactory.kt        |   1 +
 .../src/main/kotlin/renderers/html/HtmlRenderer.kt |  22 ++--
 .../main/kotlin/signatures/JvmSignatureUtils.kt    |  27 ++--
 .../kotlin/signatures/KotlinSignatureProvider.kt   |  65 ++++++----
 .../main/kotlin/templating/jsonMapperForPlugins.kt |   1 +
 .../documentables/ActualTypealiasAdder.kt          |   6 +-
 .../documentables/DefaultDocumentableMerger.kt     |   6 +-
 .../DocumentableVisibilityFilterTransformer.kt     |  12 +-
 ...nheritedEntriesDocumentableFilterTransformer.kt |  12 +-
 .../pages/comments/DocTagToContentConverter.kt     |  23 ++--
 .../DefaultDescriptorToDocumentableTranslator.kt   |  81 ++++++------
 plugins/base/src/test/kotlin/basic/DRITest.kt      |  11 +-
 .../kotlin/content/ContentInDescriptionTest.kt     |   2 +-
 .../kotlin/content/params/ContentForParamsTest.kt  |   2 +-
 .../ContentForClassWithParamsAndPropertiesTest.kt  |  12 +-
 .../content/receiver/ContentForReceiverTest.kt     |   6 +-
 .../src/test/kotlin/expect/AbstractExpectTest.kt   |   2 +-
 .../test/kotlin/expectActuals/ExpectActualsTest.kt |  18 +--
 .../test/kotlin/filter/JavaVisibilityFilterTest.kt |  14 ++-
 .../src/test/kotlin/filter/VisibilityFilterTest.kt |  10 ++
 .../kotlin/linkableContent/LinkableContentTest.kt  |  28 ++---
 plugins/base/src/test/kotlin/markdown/KDocTest.kt  |   2 +-
 plugins/base/src/test/kotlin/markdown/LinkTest.kt  |   2 +-
 plugins/base/src/test/kotlin/model/CommentTest.kt  |  82 ------------
 .../test/kotlin/pageMerger/PageNodeMergerTest.kt   |   8 +-
 .../kotlin/renderers/html/FormattingUtilsTest.kt   |   2 +-
 .../test/kotlin/resourceLinks/ResourceLinksTest.kt |   6 +-
 .../kotlin/signatures/AbstractRenderingTest.kt     |   4 +-
 .../MergeImplicitExpectActualDeclarationsTest.kt   |   6 +-
 ...efaultDescriptorToDocumentableTranslatorTest.kt |  52 ++++----
 .../DefaultPsiToDocumentableTranslatorTest.kt      |   1 +
 .../translators/JavadocInheritedDocTagsTest.kt     |   1 +
 .../dokka/gfm/renderer/CommonmarkRenderer.kt       |  19 +--
 .../jetbrains/dokka/javadoc/JavadocPageCreator.kt  |  11 +-
 .../dokka/javadoc/pages/htmlPreprocessors.kt       |   7 +-
 .../dokka/javadoc/renderer/KorteJavadocRenderer.kt |   4 +-
 .../javadoc/JavadocClasslikeTemplateMapTest.kt     |   2 +
 .../dokka/javadoc/JavadocDeprecatedTest.kt         |   3 +
 .../jetbrains/dokka/javadoc/JavadocIndexTest.kt    |   3 +
 .../dokka/javadoc/JavadocPackageTemplateMapTest.kt |   2 +
 .../kotlin/signatures/JavaSignatureProvider.kt     |  18 +--
 .../transformers/JvmNameDocumentableTransformer.kt |   9 +-
 .../AddToNavigationCommandResolutionTest.kt        | 137 +++++++++++++++++++++
 .../templates/AddToSearchCommandResolutionTest.kt  |  83 +++++++++++++
 .../templates/SubstitutionCommandResolutionTest.kt | 111 +++++++++++++++++
 .../templates/TemplatingDokkaTestGenerator.kt      |  69 +++++++++++
 .../dokka/templates/TestTemplatingGeneration.kt    |  30 +++++
 .../dokka/templates/TestTemplatingPlugin.kt        |  16 +++
 .../AddToNavigationCommandResolutionTest.kt        | 137 ---------------------
 .../templates/AddToSearchCommandResolutionTest.kt  |  83 -------------
 .../templates/SubstitutionCommandResolutionTest.kt | 111 -----------------
 .../templates/TemplatingDokkaTestGenerator.kt      |  69 -----------
 .../kotlin/templates/TestTemplatingGeneration.kt   |  30 -----
 .../test/kotlin/templates/TestTemplatingPlugin.kt  |  16 ---
 .../DefaultPreviousDocumentationCopyPostAction.kt  |  54 ++++++++
 .../versioning/ReplaceVersionCommandConsumer.kt    |  50 ++++++++
 .../dokka/versioning/ReplaceVersionsCommand.kt     |  25 ++++
 .../dokka/versioning/VersioningConfiguration.kt    |  34 +++++
 .../jetbrains/dokka/versioning/VersioningPlugin.kt |  52 ++++++++
 .../dokka/versioning/VersioningStorage.kt          |  65 ++++++++++
 .../dokka/versioning/VersionsNavigationCreator.kt  |  86 +++++++++++++
 .../jetbrains/dokka/versioning/VersionsOrdering.kt |  23 ++++
 .../dokka/versioning/htmlPreprocessors.kt          |  38 ++++++
 .../DefaultPreviousDocumentationCopyPostAction.kt  |  54 --------
 .../versioning/ReplaceVersionCommandConsumer.kt    |  50 --------
 .../kotlin/versioning/ReplaceVersionsCommand.kt    |  25 ----
 .../kotlin/versioning/VersioningConfiguration.kt   |  34 -----
 .../src/main/kotlin/versioning/VersioningPlugin.kt |  52 --------
 .../main/kotlin/versioning/VersioningStorage.kt    |  65 ----------
 .../kotlin/versioning/VersionsNavigationCreator.kt |  86 -------------
 .../src/main/kotlin/versioning/VersionsOrdering.kt |  23 ----
 .../main/kotlin/versioning/htmlPreprocessors.kt    |  38 ------
 74 files changed, 1174 insertions(+), 1183 deletions(-)
 create mode 100644 plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToNavigationCommandResolutionTest.kt
 create mode 100644 plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToSearchCommandResolutionTest.kt
 create mode 100644 plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/SubstitutionCommandResolutionTest.kt
 create mode 100644 plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TemplatingDokkaTestGenerator.kt
 create mode 100644 plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingGeneration.kt
 create mode 100644 plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingPlugin.kt
 delete mode 100644 plugins/templating/src/test/kotlin/templates/AddToNavigationCommandResolutionTest.kt
 delete mode 100644 plugins/templating/src/test/kotlin/templates/AddToSearchCommandResolutionTest.kt
 delete mode 100644 plugins/templating/src/test/kotlin/templates/SubstitutionCommandResolutionTest.kt
 delete mode 100644 plugins/templating/src/test/kotlin/templates/TemplatingDokkaTestGenerator.kt
 delete mode 100644 plugins/templating/src/test/kotlin/templates/TestTemplatingGeneration.kt
 delete mode 100644 plugins/templating/src/test/kotlin/templates/TestTemplatingPlugin.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/DefaultPreviousDocumentationCopyPostAction.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionCommandConsumer.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionsCommand.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningConfiguration.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningPlugin.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningStorage.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsNavigationCreator.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsOrdering.kt
 create mode 100644 plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/htmlPreprocessors.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/DefaultPreviousDocumentationCopyPostAction.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/ReplaceVersionCommandConsumer.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/ReplaceVersionsCommand.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/VersioningConfiguration.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/VersioningPlugin.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/VersioningStorage.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/VersionsNavigationCreator.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/VersionsOrdering.kt
 delete mode 100644 plugins/versioning/src/main/kotlin/versioning/htmlPreprocessors.kt

(limited to 'plugins')

diff --git a/plugins/base/base-test-utils/src/main/kotlin/utils/assertHtmlEqualsIgnoringWhitespace.kt b/plugins/base/base-test-utils/src/main/kotlin/utils/assertHtmlEqualsIgnoringWhitespace.kt
index 95dcae4e..eeeea265 100644
--- a/plugins/base/base-test-utils/src/main/kotlin/utils/assertHtmlEqualsIgnoringWhitespace.kt
+++ b/plugins/base/base-test-utils/src/main/kotlin/utils/assertHtmlEqualsIgnoringWhitespace.kt
@@ -1,8 +1,8 @@
 package utils
 
-import junit.framework.Assert.assertEquals
 import org.jsoup.Jsoup
 import org.jsoup.nodes.Document
+import kotlin.test.assertEquals
 
 /**
  * Parses it using JSOUP, trims whitespace at the end of the line and asserts if they are equal
diff --git a/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt b/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
index 75617e0c..d3006f33 100644
--- a/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
+++ b/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
@@ -74,7 +74,7 @@ open class MarkdownParser(
             ).flatMap { it.children }
         )
 
-    private fun horizontalRulesHandler(node: ASTNode) =
+    private fun horizontalRulesHandler() =
         DocTagsFromIElementFactory.getInstance(MarkdownTokenTypes.HORIZONTAL_RULE)
 
     private fun emphasisHandler(node: ASTNode) =
@@ -353,7 +353,7 @@ open class MarkdownParser(
             MarkdownElementTypes.ATX_5,
             MarkdownElementTypes.ATX_6,
             -> headersHandler(node)
-            MarkdownTokenTypes.HORIZONTAL_RULE -> horizontalRulesHandler(node)
+            MarkdownTokenTypes.HORIZONTAL_RULE -> horizontalRulesHandler()
             MarkdownElementTypes.STRONG -> strongHandler(node)
             MarkdownElementTypes.EMPH -> emphasisHandler(node)
             MarkdownElementTypes.FULL_REFERENCE_LINK,
diff --git a/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt b/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
index a3cbcc2e..ea87dce8 100644
--- a/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
+++ b/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
@@ -54,6 +54,7 @@ object DocTagsFromIElementFactory {
             MarkdownTokenTypes.HTML_BLOCK_CONTENT       -> Text(body.orEmpty(), params = params + contentTypeParam("html"))
             else                                        -> CustomDocTag(children, params, type.name)
         }.let {
+            @Suppress("UNCHECKED_CAST")
             when (it) {
                 is List<*> -> it as List<DocTag>
                 else -> listOf(it as DocTag)
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 05559469..7ce41866 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -367,8 +367,6 @@ open class HtmlRenderer(
         pageContext: ContentPage
     ) = // TODO: extension point there
         if (node.isImage()) {
-            //TODO: add imgAttrs parsing
-            val imgAttrs = node.extra.allOfType<SimpleAttr>().joinAttr()
             img(src = node.address, alt = node.altText)
         } else {
             println("Unrecognized resource type: $node")
@@ -377,17 +375,16 @@ open class HtmlRenderer(
     private fun FlowContent.buildRow(
         node: ContentGroup,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<DisplaySourceSet>?,
-        style: Set<Style>
+        sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
         node.children
             .filter { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }
             .takeIf { it.isNotEmpty() }
             ?.let {
                 when (pageContext) {
-                    is MultimoduleRootPage -> buildRowForMultiModule(node, it, pageContext, sourceSetRestriction, style)
-                    is ModulePage -> buildRowForModule(node, it, pageContext, sourceSetRestriction, style)
-                    else -> buildRowForContent(node, it, pageContext, sourceSetRestriction, style)
+                    is MultimoduleRootPage -> buildRowForMultiModule(node, it, pageContext, sourceSetRestriction)
+                    is ModulePage -> buildRowForModule(node, it, pageContext, sourceSetRestriction)
+                    else -> buildRowForContent(node, it, pageContext, sourceSetRestriction)
                 }
             }
     }
@@ -396,8 +393,7 @@ open class HtmlRenderer(
         contextNode: ContentGroup,
         toRender: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<DisplaySourceSet>?,
-        style: Set<Style>
+        sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
         buildAnchor(contextNode)
         div(classes = "table-row") {
@@ -414,8 +410,7 @@ open class HtmlRenderer(
         contextNode: ContentGroup,
         toRender: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<DisplaySourceSet>?,
-        style: Set<Style>
+        sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
         buildAnchor(contextNode)
         div(classes = "table-row") {
@@ -440,8 +435,7 @@ open class HtmlRenderer(
         contextNode: ContentGroup,
         toRender: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<DisplaySourceSet>?,
-        style: Set<Style>
+        sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
         buildAnchor(contextNode)
         div(classes = "table-row") {
@@ -551,7 +545,7 @@ open class HtmlRenderer(
             else -> div(classes = "table") {
                 node.extra.extraHtmlAttributes().forEach { attributes[it.extraKey] = it.extraValue }
                 node.children.forEach {
-                    buildRow(it, pageContext, sourceSetRestriction, node.style)
+                    buildRow(it, pageContext, sourceSetRestriction)
                 }
             }
         }
diff --git a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
index b6841323..dc5a9543 100644
--- a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
+++ b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
@@ -163,16 +163,23 @@ interface JvmSignatureUtils {
         }
     }
 
-    fun <T : Documentable> WithExtraProperties<T>.stylesIfDeprecated(sourceSetData: DokkaSourceSet): Set<TextStyle> =
-        if (extra[Annotations]?.directAnnotations?.get(sourceSetData)?.any {
-                it.dri == DRI("kotlin", "Deprecated")
-                        || it.dri == DRI("java.lang", "Deprecated")
-            } == true) setOf(TextStyle.Strikethrough) else emptySet()
-
-    infix fun DFunction.uses(t: DTypeParameter): Boolean {
-        val allDris: List<DRI> = (listOfNotNull(receiver?.dri, *receiver?.type?.drisOfAllNestedBounds?.toTypedArray() ?: emptyArray()) +
-                parameters.flatMap { listOf(it.dri) + it.type.drisOfAllNestedBounds })
-        return t.dri in allDris
+    fun <T : Documentable> WithExtraProperties<T>.stylesIfDeprecated(sourceSetData: DokkaSourceSet): Set<TextStyle> {
+        val directAnnotations = extra[Annotations]?.directAnnotations?.get(sourceSetData) ?: emptyList()
+        val hasAnyDeprecatedAnnotation =
+            directAnnotations.any { it.dri == DRI("kotlin", "Deprecated") || it.dri == DRI("java.lang", "Deprecated") }
+
+        return if (hasAnyDeprecatedAnnotation) setOf(TextStyle.Strikethrough) else emptySet()
+    }
+
+    infix fun DFunction.uses(typeParameter: DTypeParameter): Boolean {
+        val parameterDris = parameters.flatMap { listOf(it.dri) + it.type.drisOfAllNestedBounds }
+        val receiverDris =
+            listOfNotNull(
+                receiver?.dri,
+                *receiver?.type?.drisOfAllNestedBounds?.toTypedArray() ?: emptyArray()
+            )
+        val allDris = parameterDris + receiverDris
+        return typeParameter.dri in allDris
     }
 
     /**
diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
index ba4b4131..642c01c3 100644
--- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
+++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
@@ -13,10 +13,7 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Nullable
 import org.jetbrains.dokka.model.TypeConstructor
 import org.jetbrains.dokka.model.properties.WithExtraProperties
-import org.jetbrains.dokka.pages.ContentKind
-import org.jetbrains.dokka.pages.ContentNode
-import org.jetbrains.dokka.pages.TextStyle
-import org.jetbrains.dokka.pages.TokenStyle
+import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
 import org.jetbrains.dokka.plugability.querySingle
@@ -96,12 +93,16 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             }
         }
 
-    private fun actualTypealiasedSignature(c: DClasslike, sourceSet: DokkaSourceSet, aliasedType: Bound) =
-        contentBuilder.contentFor(
+    private fun actualTypealiasedSignature(c: DClasslike, sourceSet: DokkaSourceSet, aliasedType: Bound): ContentGroup {
+        @Suppress("UNCHECKED_CAST")
+        val deprecationStyles = (c as? WithExtraProperties<out Documentable>)
+            ?.stylesIfDeprecated(sourceSet)
+            ?: emptySet()
+
+        return contentBuilder.contentFor(
             c,
             ContentKind.Symbol,
-            setOf(TextStyle.Monospace) + ((c as? WithExtraProperties<out Documentable>)?.stylesIfDeprecated(sourceSet)
-                ?: emptySet()),
+            setOf(TextStyle.Monospace) + deprecationStyles,
             sourceSets = setOf(sourceSet)
         ) {
             keyword("actual ")
@@ -110,15 +111,24 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             operator(" = ")
             signatureForProjection(aliasedType)
         }
+    }
 
-    @Suppress("UNCHECKED_CAST")
-    private fun <T : DClasslike> classlikeSignature(c: T): List<ContentNode> =
-        c.sourceSets.map { sourceSetData ->
-            (c as? WithExtraProperties<out DClasslike>)?.extra?.get(ActualTypealias)?.underlyingType?.get(sourceSetData)
-                ?.let {
-                    actualTypealiasedSignature(c, sourceSetData, it)
-                } ?: regularSignature(c, sourceSetData)
+    private fun <T : DClasslike> classlikeSignature(c: T): List<ContentNode> {
+        @Suppress("UNCHECKED_CAST")
+        val typeAliasUnderlyingType = (c as? WithExtraProperties<out DClasslike>)
+            ?.extra
+            ?.get(ActualTypealias)
+            ?.underlyingType
+
+        return c.sourceSets.map { sourceSetData ->
+            val sourceSetType = typeAliasUnderlyingType?.get(sourceSetData)
+            if (sourceSetType == null) {
+                regularSignature(c, sourceSetData)
+            } else {
+                actualTypealiasedSignature(c, sourceSetData, sourceSetType)
+            }
         }
+    }
 
     private fun <T : Documentable> PageContentBuilder.DocumentableContentBuilder.defaultValueAssign(
         d: WithExtraProperties<T>,
@@ -134,27 +144,33 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         }
     }
 
-    private fun regularSignature(c: DClasslike, sourceSet: DokkaSourceSet) =
-        contentBuilder.contentFor(
+    private fun regularSignature(c: DClasslike, sourceSet: DokkaSourceSet): ContentGroup {
+        @Suppress("UNCHECKED_CAST")
+        val deprecationStyles = (c as? WithExtraProperties<out Documentable>)
+            ?.stylesIfDeprecated(sourceSet)
+            ?: emptySet()
+
+        return contentBuilder.contentFor(
             c,
             ContentKind.Symbol,
-            setOf(TextStyle.Monospace) + ((c as? WithExtraProperties<out Documentable>)?.stylesIfDeprecated(sourceSet)
-                ?: emptySet()),
+            setOf(TextStyle.Monospace) + deprecationStyles,
             sourceSets = setOf(sourceSet)
         ) {
             annotationsBlock(c)
             c.visibility[sourceSet]?.takeIf { it !in ignoredVisibilities }?.name?.let { keyword("$it ") }
             if (c.isExpectActual) keyword(if (sourceSet == c.expectPresentInSet) "expect " else "actual ")
             if (c is DClass) {
-               val modifier = if (c.modifier[sourceSet] !in ignoredModifiers)
+                val modifier =
+                    if (c.modifier[sourceSet] !in ignoredModifiers) {
                         when {
                             c.extra[AdditionalModifiers]?.content?.get(sourceSet)?.contains(ExtraModifiers.KotlinOnlyModifiers.Data) == true -> ""
                             c.modifier[sourceSet] is JavaModifier.Empty -> "${KotlinModifier.Open.name} "
-                            else -> c.modifier[sourceSet]?.name?.let { "$it " } ?: ""
+                            else -> c.modifier[sourceSet]?.name?.let { "$it " }
                         }
-                    else
-                        ""
-                modifier.takeIf { it.isNotEmpty() }?.let { keyword(it) }
+                    } else {
+                        null
+                    }
+                modifier?.takeIf { it.isNotEmpty() }?.let { keyword(it) }
             }
             when (c) {
                 is DClass -> {
@@ -232,6 +248,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                 }
             }
         }
+    }
 
     /**
      * An example would be a primary constructor `class A(val s: String)`,
diff --git a/plugins/base/src/main/kotlin/templating/jsonMapperForPlugins.kt b/plugins/base/src/main/kotlin/templating/jsonMapperForPlugins.kt
index 71245778..98cabd72 100644
--- a/plugins/base/src/main/kotlin/templating/jsonMapperForPlugins.kt
+++ b/plugins/base/src/main/kotlin/templating/jsonMapperForPlugins.kt
@@ -49,6 +49,7 @@ private object FileSerializer : StdScalarSerializer<File>(File::class.java) {
     }
 }
 
+@Suppress("DEPRECATION") // for TypeFactory constructor, no way to use non-deprecated one, it's essentially identical
 private class PluginTypeFactory: TypeFactory(null) {
     override fun findClass(className: String): Class<out Any>? =
         Class.forName(className, true, DokkaBase::class.java.classLoader) ?: super.findClass(className)
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
index a9b99840..58c601bc 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
@@ -66,7 +66,7 @@ class ActualTypealiasAdder : DocumentableTransformer {
         elements.map { element ->
             if (element.expectPresentInSet != null) {
                 typealiases[element.dri]?.let { ta ->
-                    element.withNewExtras(element.extra + ActualTypealias(ta.underlyingType)).let {
+                    val merged = element.withNewExtras(element.extra + ActualTypealias(ta.underlyingType)).let {
                         when(it) {
                             is DClass -> it.copy(sourceSets = element.sourceSets + ta.sourceSets)
                             is DEnum ->  it.copy(sourceSets = element.sourceSets + ta.sourceSets)
@@ -75,7 +75,9 @@ class ActualTypealiasAdder : DocumentableTransformer {
                             is DAnnotation -> it.copy(sourceSets = element.sourceSets + ta.sourceSets)
                             else -> throw IllegalStateException("${it::class.qualifiedName} ${it.name} cannot have copy its sourceSets")
                         }
-                    } as T
+                    }
+                    @Suppress("UNCHECKED_CAST")
+                    merged as T
                 } ?: element
             } else {
                 element
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
index 6239ad6b..17e3cbcd 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
@@ -49,7 +49,7 @@ internal class DefaultDocumentableMerger(val context: DokkaContext) : Documentab
 
         fun mergeClashingElements(elements: List<Pair<T, Set<DokkaConfiguration.DokkaSourceSet>>>): List<T> =
             elements.groupBy { it.first.name }.values.flatMap { listOfDocumentableToSSIds ->
-                listOfDocumentableToSSIds.map { (documentable, sourceSets) ->
+                val merged = listOfDocumentableToSSIds.map { (documentable, sourceSets) ->
                     when (documentable) {
                         is DClass -> documentable.copy(
                             extra = documentable.extra + ClashingDriIdentifier(
@@ -88,7 +88,9 @@ internal class DefaultDocumentableMerger(val context: DokkaContext) : Documentab
                         )
                         else -> documentable
                     }
-                } as List<T>
+                }
+                @Suppress("UNCHECKED_CAST")
+                merged as List<T>
             }
 
 
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
index 4ca3d861..94688799 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
@@ -35,10 +35,12 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
                 packageOptions.firstOrNull { Regex(it.matchingRegex).matches(name) }
             }
 
-            val (documentedVisibilities, includeNonPublic) = when {
-                packageOpts != null -> packageOpts.documentedVisibilities to packageOpts.includeNonPublic
-                else -> globalOptions.documentedVisibilities to globalOptions.includeNonPublic
-            }
+            val (documentedVisibilities, includeNonPublic) =
+                @Suppress("DEPRECATION") // for includeNonPublic, preserve backwards compatibility
+                when {
+                    packageOpts != null -> packageOpts.documentedVisibilities to packageOpts.includeNonPublic
+                    else -> globalOptions.documentedVisibilities to globalOptions.includeNonPublic
+                }
 
             // if `documentedVisibilities` is explicitly overridden by the user (i.e. not default value by reference),
             // deprecated `includeNonPublic` should not be taken into account, so that only one setting prevails
@@ -176,7 +178,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
         ): Pair<Boolean, List<DProperty>> {
 
             val modifier: (DProperty, Set<DokkaSourceSet>) -> Pair<Boolean, DProperty> =
-                { original, filteredPlatforms ->
+                { original, _ ->
                     val setter = original.setter?.let { filterFunctions(listOf(it), additionalConditionAccessors) }
                     val getter = original.getter?.let { filterFunctions(listOf(it), additionalConditionAccessors) }
 
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/InheritedEntriesDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/InheritedEntriesDocumentableFilterTransformer.kt
index a1b5052d..2e4b29ff 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/InheritedEntriesDocumentableFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/InheritedEntriesDocumentableFilterTransformer.kt
@@ -6,8 +6,12 @@ import org.jetbrains.dokka.plugability.DokkaContext
 
 class InheritedEntriesDocumentableFilterTransformer(context: DokkaContext) :
     SuppressedByConditionDocumentableFilterTransformer(context) {
-    override fun shouldBeSuppressed(d: Documentable): Boolean =
-        context.configuration.suppressInheritedMembers && (d as? WithExtraProperties<Documentable>)?.extra?.get(
-            InheritedMember
-        )?.inheritedFrom?.any { entry -> entry.value != null } ?: false
+
+    override fun shouldBeSuppressed(d: Documentable): Boolean {
+        @Suppress("UNCHECKED_CAST")
+        val inheritedMember = (d as? WithExtraProperties<Documentable>)?.extra?.get(InheritedMember)
+        val containsInheritedFrom = inheritedMember?.inheritedFrom?.any { entry -> entry.value != null } ?: false
+
+        return context.configuration.suppressInheritedMembers && containsInheritedFrom
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
index c38edea8..85b082ef 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
@@ -15,17 +15,18 @@ open class DocTagToContentConverter : CommentsToContentConverter {
         dci: DCI,
         sourceSets: Set<DokkaSourceSet>,
         styles: Set<Style>,
-        extra: PropertyContainer<ContentNode>
+        extras: PropertyContainer<ContentNode>
     ): List<ContentNode> {
 
         fun buildChildren(docTag: DocTag, newStyles: Set<Style> = emptySet(), newExtras: SimpleAttr? = null) =
             docTag.children.flatMap {
-                buildContent(it, dci, sourceSets, styles + newStyles, newExtras?.let { extra + it } ?: extra)
+                buildContent(it, dci, sourceSets, styles + newStyles, newExtras?.let { extras + it } ?: extras)
             }
 
         fun buildTableRows(rows: List<DocTag>, newStyle: Style): List<ContentGroup> =
             rows.flatMap {
-                buildContent(it, dci, sourceSets, styles + newStyle, extra) as List<ContentGroup>
+                @Suppress("UNCHECKED_CAST")
+                buildContent(it, dci, sourceSets, styles + newStyle, extras) as List<ContentGroup>
             }
 
         fun buildHeader(level: Int) =
@@ -70,7 +71,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
             is Ul -> buildList(false)
             is Ol -> buildList(true, start = docTag.params["start"]?.toInt() ?: 1)
             is Li -> listOf(
-                ContentGroup(buildChildren(docTag), dci, sourceSets.toDisplaySourceSets(), styles, extra)
+                ContentGroup(buildChildren(docTag), dci, sourceSets.toDisplaySourceSets(), styles, extras)
             )
             is Dl -> buildList(false, newStyles = setOf(ListStyle.DescriptionList))
             is Dt -> listOf(
@@ -98,7 +99,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                     dci,
                     sourceSets.toDisplaySourceSets(),
                     styles + setOf(TextStyle.Paragraph),
-                    extra
+                    extras
                 )
             )
             is A -> listOf(
@@ -147,7 +148,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                     dci = dci,
                     sourceSets = sourceSets.toDisplaySourceSets(),
                     style = styles,
-                    extra = extra
+                    extra = extras
                 )
             )
             is HorizontalRule -> listOf(
@@ -164,7 +165,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                     dci,
                     sourceSets.toDisplaySourceSets(),
                     styles,
-                    extra + HtmlContent.takeIf { docTag.params["content-type"] == "html" }
+                    extras + HtmlContent.takeIf { docTag.params["content-type"] == "html" }
                 )
             )
             is Strikethrough -> buildChildren(docTag, setOf(TextStyle.Strikethrough))
@@ -182,7 +183,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                                     dci,
                                     sourceSets.toDisplaySourceSets(),
                                     styles,
-                                    extra
+                                    extras
                                 )
                             },
                             buildTableRows(body.filterIsInstance<Tr>(), CommentTable),
@@ -208,7 +209,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
             is Tr -> listOf(
                 ContentGroup(
                     docTag.children.map {
-                        ContentGroup(buildChildren(it), dci, sourceSets.toDisplaySourceSets(), styles, extra)
+                        ContentGroup(buildChildren(it), dci, sourceSets.toDisplaySourceSets(), styles, extras)
                     },
                     dci,
                     sourceSets.toDisplaySourceSets(),
@@ -230,7 +231,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                         dci,
                         sourceSets.toDisplaySourceSets(),
                         styles,
-                        extra = extra
+                        extra = extras
                     )
                 )
             } else {
@@ -242,7 +243,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                     dci,
                     sourceSets.toDisplaySourceSets(),
                     styles + ContentStyle.Caption,
-                    extra = extra
+                    extra = extras
                 )
             )
 
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index 91848963..85ec1d07 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -14,7 +14,6 @@ import org.jetbrains.dokka.analysis.from
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.parsers.MarkdownParser
 import org.jetbrains.dokka.base.translators.psi.parsers.JavadocParser
-import org.jetbrains.dokka.base.translators.psi.DefaultPsiToDocumentableTranslator
 import org.jetbrains.dokka.base.translators.typeConstructorsBeingExceptions
 import org.jetbrains.dokka.base.translators.unquotedValue
 import org.jetbrains.dokka.links.*
@@ -96,8 +95,7 @@ class DefaultDescriptorToDocumentableTranslator(
         return DokkaDescriptorVisitor(sourceSet, kotlinAnalysis[sourceSet].facade, context.logger).run {
             packageFragments.mapNotNull { it.safeAs<PackageFragmentDescriptor>() }.parallelMap {
                 visitPackageFragmentDescriptor(
-                    it,
-                    DRIWithPlatformInfo(DRI.topLevel, emptyMap())
+                    it
                 )
             }
         }.let {
@@ -145,20 +143,17 @@ private class DokkaDescriptorVisitor(
 
     private fun <T> T.toSourceSetDependent() = if (this != null) mapOf(sourceSet to this) else emptyMap()
 
-    suspend fun visitPackageFragmentDescriptor(
-        descriptor: PackageFragmentDescriptor,
-        parent: DRIWithPlatformInfo
-    ): DPackage {
+    suspend fun visitPackageFragmentDescriptor(descriptor: PackageFragmentDescriptor): DPackage {
         val name = descriptor.fqName.asString().takeUnless { it.isBlank() } ?: ""
         val driWithPlatform = DRI(packageName = name).withEmptyInfo()
         val scope = descriptor.getMemberScope()
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind(true)
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-            val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases(driWithPlatform) }
+            val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases() }
 
             DPackage(
                 dri = driWithPlatform.dri,
@@ -191,8 +186,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
             val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
 
@@ -232,8 +227,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
 
             DObject(
@@ -271,8 +266,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
             val constructors =
                 async { descriptor.constructors.parallelMap { visitConstructorDescriptor(it, driWithPlatform) } }
@@ -311,8 +306,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
 
             DEnumEntry(
@@ -342,8 +337,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
             val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
             val constructors =
@@ -385,8 +380,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
             val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
             val constructors = async {
@@ -426,10 +421,7 @@ private class DokkaDescriptorVisitor(
         }
     }
 
-    private suspend fun visitPropertyDescriptor(
-        originalDescriptor: PropertyDescriptor,
-        parent: DRIWithPlatformInfo
-    ): DProperty {
+    private suspend fun visitPropertyDescriptor(originalDescriptor: PropertyDescriptor): DProperty {
         val (dri, inheritedFrom) = originalDescriptor.createDRI()
         val descriptor = originalDescriptor.getConcreteDescriptor()
         val isExpect = descriptor.isExpect
@@ -481,10 +473,7 @@ private class DokkaDescriptorVisitor(
         else
             overriddenDescriptors.first().createDRI(DRI.from(this))
 
-    private suspend fun visitFunctionDescriptor(
-        originalDescriptor: FunctionDescriptor,
-        parent: DRIWithPlatformInfo
-    ): DFunction {
+    private suspend fun visitFunctionDescriptor(originalDescriptor: FunctionDescriptor): DFunction {
         val (dri, inheritedFrom) = originalDescriptor.createDRI()
         val descriptor = originalDescriptor.getConcreteDescriptor()
         val isExpect = descriptor.isExpect
@@ -675,7 +664,7 @@ private class DokkaDescriptorVisitor(
         }
     }
 
-    private suspend fun visitTypeAliasDescriptor(descriptor: TypeAliasDescriptor, parent: DRIWithPlatformInfo?) =
+    private suspend fun visitTypeAliasDescriptor(descriptor: TypeAliasDescriptor) =
         with(descriptor) {
             coroutineScope {
                 val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
@@ -742,6 +731,7 @@ private class DokkaDescriptorVisitor(
             }
         }
 
+        @Suppress("UNCHECKED_CAST")
         return DescriptorsWithKind(
             (groupedDescriptors[FunctionDescriptor::class] ?: emptyList()) as List<FunctionDescriptor>,
             (groupedDescriptors[PropertyDescriptor::class] ?: emptyList()) as List<PropertyDescriptor>,
@@ -751,17 +741,17 @@ private class DokkaDescriptorVisitor(
         )
     }
 
-    private suspend fun List<FunctionDescriptor>.visitFunctions(parent: DRIWithPlatformInfo): List<DFunction> =
-        coroutineScope { parallelMap { visitFunctionDescriptor(it, parent) } }
+    private suspend fun List<FunctionDescriptor>.visitFunctions(): List<DFunction> =
+        coroutineScope { parallelMap { visitFunctionDescriptor(it) } }
 
-    private suspend fun List<PropertyDescriptor>.visitProperties(parent: DRIWithPlatformInfo): List<DProperty> =
-        coroutineScope { parallelMap { visitPropertyDescriptor(it, parent) } }
+    private suspend fun List<PropertyDescriptor>.visitProperties(): List<DProperty> =
+        coroutineScope { parallelMap { visitPropertyDescriptor(it) } }
 
     private suspend fun List<ClassDescriptor>.visitClasslikes(parent: DRIWithPlatformInfo): List<DClasslike> =
         coroutineScope { parallelMap { visitClassDescriptor(it, parent) } }
 
-    private suspend fun List<TypeAliasDescriptor>.visitTypealiases(parent: DRIWithPlatformInfo): List<DTypeAlias> =
-        coroutineScope { parallelMap { visitTypeAliasDescriptor(it, parent) } }
+    private suspend fun List<TypeAliasDescriptor>.visitTypealiases(): List<DTypeAlias> =
+        coroutineScope { parallelMap { visitTypeAliasDescriptor(it) } }
 
     private suspend fun List<ClassDescriptor>.visitEnumEntries(parent: DRIWithPlatformInfo): List<DEnumEntry> =
         coroutineScope { parallelMap { visitEnumEntryDescriptor(it, parent) } }
@@ -972,7 +962,7 @@ private class DokkaDescriptorVisitor(
 
     private fun ConstantValue<*>.toValue(): AnnotationParameterValue = when (this) {
         is ConstantsAnnotationValue -> AnnotationValue(value.toAnnotation())
-        is ConstantsArrayValue -> ArrayValue(value.mapNotNull { it.toValue() })
+        is ConstantsArrayValue -> ArrayValue(value.map { it.toValue() })
         is ConstantsEnumValue -> EnumValue(
             fullEnumEntryName(),
             DRI(enumClassId.packageFqName.asString(), fullEnumEntryName())
@@ -1005,9 +995,7 @@ private class DokkaDescriptorVisitor(
     private fun AnnotationDescriptor.toAnnotation(scope: Annotations.AnnotationScope = Annotations.AnnotationScope.DIRECT): Annotations.Annotation =
         Annotations.Annotation(
             DRI.from(annotationClass as DeclarationDescriptor),
-            allValueArguments.map { it.key.asString() to it.value.toValue() }.filter {
-                it.second != null
-            }.toMap(),
+            allValueArguments.map { it.key.asString() to it.value.toValue() }.toMap(),
             mustBeDocumented(),
             scope
         )
@@ -1027,9 +1015,14 @@ private class DokkaDescriptorVisitor(
         }
     }
 
-    private fun <T : CallableMemberDescriptor> T.getConcreteDescriptor(): T =
-        if (kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) this
-        else overriddenDescriptors.first().getConcreteDescriptor() as T
+    private fun <T : CallableMemberDescriptor> T.getConcreteDescriptor(): T {
+        return if (kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+            this
+        } else {
+            @Suppress("UNCHECKED_CAST")
+            overriddenDescriptors.first().getConcreteDescriptor() as T
+        }
+    }
 
     private fun ValueParameterDescriptor.getDefaultValue(): Expression? =
         ((source as? KotlinSourceElement)?.psi as? KtParameter)?.defaultValue?.toDefaultValueExpression()
diff --git a/plugins/base/src/test/kotlin/basic/DRITest.kt b/plugins/base/src/test/kotlin/basic/DRITest.kt
index 57e05858..3a4ff84d 100644
--- a/plugins/base/src/test/kotlin/basic/DRITest.kt
+++ b/plugins/base/src/test/kotlin/basic/DRITest.kt
@@ -190,7 +190,7 @@ class DRITest : BaseAbstractTest() {
         ) {
             pagesGenerationStage = { module ->
                 val sampleClass = module.dfs { it.name == "Sample" } as ClasslikePageNode
-                val classDocumentable = sampleClass.documentable as DClass
+                val classDocumentable = sampleClass.documentables.firstOrNull() as DClass
 
                 assertEquals( "example/Sample///PointingToDeclaration/", sampleClass.dri.first().toString())
                 assertEquals("example/Sample///PointingToGenericParameters(0)/", classDocumentable.generics.first().dri.toString())
@@ -224,7 +224,7 @@ class DRITest : BaseAbstractTest() {
             pagesGenerationStage = { module ->
                 val sampleClass = module.dfs { it.name == "Sample" } as ClasslikePageNode
                 val functionNode = sampleClass.children.first { it.name == "genericFun" } as MemberPageNode
-                val functionDocumentable = functionNode.documentable as DFunction
+                val functionDocumentable = functionNode.documentables.firstOrNull() as DFunction
                 val parameter = functionDocumentable.parameters.first()
 
                 assertEquals("example/Sample/genericFun/#kotlin.String/PointingToDeclaration/", functionNode.dri.first().toString())
@@ -269,9 +269,10 @@ class DRITest : BaseAbstractTest() {
                 val sampleClass = module.dfs { it.name == "Sample" } as ClasslikePageNode
                 val sampleInner = sampleClass.children.first { it.name == "SampleInner" } as ClasslikePageNode
                 val foo = sampleInner.children.first { it.name == "foo" } as MemberPageNode
-                val documentable = foo.documentable as DFunction
+                val documentable = foo.documentables.firstOrNull() as DFunction
 
-                assertEquals((sampleClass.documentable as WithGenerics).generics.first().dri.toString(), (documentable.type as TypeParameter).dri.toString())
+                val generics = (sampleClass.documentables.firstOrNull() as WithGenerics).generics
+                assertEquals(generics.first().dri.toString(), (documentable.type as TypeParameter).dri.toString())
                 assertEquals(0, documentable.generics.size)
             }
         }
@@ -298,7 +299,7 @@ class DRITest : BaseAbstractTest() {
         ) {
             pagesGenerationStage = { module ->
                 val extensionFunction = module.dfs { it.name == "extensionFunction" } as MemberPageNode
-                val documentable = extensionFunction.documentable as DFunction
+                val documentable = extensionFunction.documentables.firstOrNull() as DFunction
 
                 assertEquals(
                     "example//extensionFunction/kotlin.collections.List[TypeParam(bounds=[kotlin.Any?])]#/PointingToDeclaration/",
diff --git a/plugins/base/src/test/kotlin/content/ContentInDescriptionTest.kt b/plugins/base/src/test/kotlin/content/ContentInDescriptionTest.kt
index b44eb651..e5533a7e 100644
--- a/plugins/base/src/test/kotlin/content/ContentInDescriptionTest.kt
+++ b/plugins/base/src/test/kotlin/content/ContentInDescriptionTest.kt
@@ -1,9 +1,9 @@
 package content
 
-import junit.framework.Assert.assertEquals
 import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
 import org.jetbrains.dokka.model.doc.*
 import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class ContentInDescriptionTest : BaseAbstractTest() {
diff --git a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
index 664b8282..50580afc 100644
--- a/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
+++ b/plugins/base/src/test/kotlin/content/params/ContentForParamsTest.kt
@@ -1412,7 +1412,7 @@ class ContentForParamsTest : BaseAbstractTest() {
                     it is MemberPageNode && it.dri.first()
                         .toString() == "test/Main/sample/#java.lang.String#java.lang.String/PointingToDeclaration/"
                 } as MemberPageNode
-                val forJvm = (sampleFunction.documentable as DFunction).parameters.mapNotNull {
+                val forJvm = (sampleFunction.documentables.firstOrNull() as DFunction).parameters.mapNotNull {
                     val jvm = it.documentation.keys.first { it.analysisPlatform == Platform.jvm }
                     it.documentation[jvm]
                 }
diff --git a/plugins/base/src/test/kotlin/content/properties/ContentForClassWithParamsAndPropertiesTest.kt b/plugins/base/src/test/kotlin/content/properties/ContentForClassWithParamsAndPropertiesTest.kt
index 5bd152dc..164fa62d 100644
--- a/plugins/base/src/test/kotlin/content/properties/ContentForClassWithParamsAndPropertiesTest.kt
+++ b/plugins/base/src/test/kotlin/content/properties/ContentForClassWithParamsAndPropertiesTest.kt
@@ -24,7 +24,7 @@ class ContentForClassWithParamsAndPropertiesTest : BaseAbstractTest() {
         propertyTest { rootPage ->
             val node = rootPage.dfs { it.name == "LoadInitialParams" } as ClasslikePageNode
             val actualDocsForPlaceholdersEnabled =
-                (node.documentable as DClass).constructors.first().parameters.find { it.name == "placeholdersEnabled" }
+                (node.documentables.firstOrNull() as DClass).constructors.first().parameters.find { it.name == "placeholdersEnabled" }
                     ?.documentation?.entries?.first()?.value
             assertEquals(DocumentationNode(listOf(docsForPlaceholdersEnabled)), actualDocsForPlaceholdersEnabled)
         }
@@ -35,7 +35,7 @@ class ContentForClassWithParamsAndPropertiesTest : BaseAbstractTest() {
         propertyTest { rootPage ->
             val node = rootPage.dfs { it.name == "LoadInitialParams" } as ClasslikePageNode
             val actualDocsForRequestedLoadSize =
-                (node.documentable as DClass).constructors.first().parameters.find { it.name == "requestedLoadSize" }
+                (node.documentables.firstOrNull() as DClass).constructors.first().parameters.find { it.name == "requestedLoadSize" }
                     ?.documentation?.entries?.first()?.value
             assertEquals(DocumentationNode(listOf(docsForRequestedLoadSize)), actualDocsForRequestedLoadSize)
         }
@@ -47,7 +47,7 @@ class ContentForClassWithParamsAndPropertiesTest : BaseAbstractTest() {
             val node = rootPage.dfs { it.name == "LoadInitialParams" } as ClasslikePageNode
 
             val actualDocsForRequestedInitialKey =
-                (node.documentable as DClass).constructors.first().parameters.find { it.name == "requestedInitialKey" }
+                (node.documentables.firstOrNull() as DClass).constructors.first().parameters.find { it.name == "requestedInitialKey" }
                     ?.documentation?.entries?.first()?.value
             assertEquals(DocumentationNode(listOf(docsForRequestedInitialKey)), actualDocsForRequestedInitialKey)
         }
@@ -71,7 +71,7 @@ class ContentForClassWithParamsAndPropertiesTest : BaseAbstractTest() {
             val node = rootPage.dfs { it.name == "LoadInitialParams" } as ClasslikePageNode
 
             val actualDocs =
-                (node.documentable as DClass).constructors.first().documentation.entries.first().value
+                (node.documentables.firstOrNull() as DClass).constructors.first().documentation.entries.first().value
             assertEquals(DocumentationNode(listOf(constructorDocs, docsForParam)), actualDocs)
         }
     }
@@ -94,7 +94,7 @@ class ContentForClassWithParamsAndPropertiesTest : BaseAbstractTest() {
             val node = rootPage.dfs { it.name == "LoadInitialParams" } as ClasslikePageNode
 
             val actualDocs =
-                (node.documentable as DClass).documentation.entries.first().value
+                (node.documentables.firstOrNull() as DClass).documentation.entries.first().value
             assertEquals(
                 DocumentationNode(
                     listOf(
@@ -129,7 +129,7 @@ class ContentForClassWithParamsAndPropertiesTest : BaseAbstractTest() {
             val node = rootPage.dfs { it.name == "ItemKeyedDataSource" } as ClasslikePageNode
 
             val actualDocs =
-                (node.documentable as DClass).properties.first().documentation.entries.first().value
+                (node.documentables.firstOrNull() as DClass).properties.first().documentation.entries.first().value
             assertEquals(
                 DocumentationNode(listOf(ownDescription)),
                 actualDocs
diff --git a/plugins/base/src/test/kotlin/content/receiver/ContentForReceiverTest.kt b/plugins/base/src/test/kotlin/content/receiver/ContentForReceiverTest.kt
index e566320c..d7399914 100644
--- a/plugins/base/src/test/kotlin/content/receiver/ContentForReceiverTest.kt
+++ b/plugins/base/src/test/kotlin/content/receiver/ContentForReceiverTest.kt
@@ -1,7 +1,5 @@
 package content.receiver
 
-import junit.framework.Assert.assertEquals
-import junit.framework.Assert.assertNotNull
 import org.jetbrains.dokka.base.testApi.testRunner.BaseAbstractTest
 import org.jetbrains.dokka.model.dfs
 import org.jetbrains.dokka.model.doc.Receiver
@@ -11,6 +9,8 @@ import org.jetbrains.dokka.pages.ContentText
 import org.jetbrains.dokka.pages.MemberPageNode
 import org.junit.jupiter.api.Test
 import utils.docs
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
 
 class ContentForReceiverTest: BaseAbstractTest() {
     private val testConfiguration = dokkaConfiguration {
@@ -40,7 +40,7 @@ class ContentForReceiverTest: BaseAbstractTest() {
                 with(module.packages.flatMap { it.functions }.first()){
                     val receiver = docs().firstOrNull { it is Receiver }
                     assertNotNull(receiver)
-                    val content = receiver?.dfs { it is Text } as Text
+                    val content = receiver.dfs { it is Text } as Text
                     assertEquals("docs for string", content.body)
                 }
             }
diff --git a/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt b/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
index d1b8153d..1d86f219 100644
--- a/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
+++ b/plugins/base/src/test/kotlin/expect/AbstractExpectTest.kt
@@ -52,7 +52,7 @@ abstract class AbstractExpectTest(
         excludes: List<String>,
         timeout: Long = 500
     ) {
-        obtained?.let { path ->
+        obtained?.let { _ ->
             val (res, out, err) = runDiff(expected, obtained, excludes, timeout)
             assertTrue(res == 0, "Outputs differ:\nstdout - $out\n\nstderr - ${err ?: ""}")
         } ?: throw AssertionError("obtained path is null")
diff --git a/plugins/base/src/test/kotlin/expectActuals/ExpectActualsTest.kt b/plugins/base/src/test/kotlin/expectActuals/ExpectActualsTest.kt
index e7c45abd..13d4b456 100644
--- a/plugins/base/src/test/kotlin/expectActuals/ExpectActualsTest.kt
+++ b/plugins/base/src/test/kotlin/expectActuals/ExpectActualsTest.kt
@@ -43,42 +43,42 @@ class ExpectActualsTest : BaseAbstractTest() {
                     sourceRoots = listOf("src/commonN2Main/kotlin/pageMerger/Test.kt")
                     dependentSourceSets = setOf(common.value.sourceSetID)
                 }
-                val js = sourceSet {
+                sourceSet {
                     name = "js"
                     displayName = "js"
                     analysisPlatform = "js"
                     dependentSourceSets = setOf(commonJ.value.sourceSetID)
                     sourceRoots = listOf("src/jsMain/kotlin/pageMerger/Test.kt")
                 }
-                val jvm = sourceSet {
+                sourceSet {
                     name = "jvm"
                     displayName = "jvm"
                     analysisPlatform = "jvm"
                     dependentSourceSets = setOf(commonJ.value.sourceSetID)
                     sourceRoots = listOf("src/jvmMain/kotlin/pageMerger/Test.kt")
                 }
-                val linuxX64 = sourceSet {
+                sourceSet {
                     name = "linuxX64"
                     displayName = "linuxX64"
                     analysisPlatform = "native"
                     dependentSourceSets = setOf(commonN1.value.sourceSetID)
                     sourceRoots = listOf("src/linuxX64Main/kotlin/pageMerger/Test.kt")
                 }
-                val mingwX64 = sourceSet {
+                sourceSet {
                     name = "mingwX64"
                     displayName = "mingwX64"
                     analysisPlatform = "native"
                     dependentSourceSets = setOf(commonN1.value.sourceSetID)
                     sourceRoots = listOf("src/mingwX64Main/kotlin/pageMerger/Test.kt")
                 }
-                val iosArm64 = sourceSet {
+                sourceSet {
                     name = "iosArm64"
                     displayName = "iosArm64"
                     analysisPlatform = "native"
                     dependentSourceSets = setOf(commonN2.value.sourceSetID)
                     sourceRoots = listOf("src/iosArm64Main/kotlin/pageMerger/Test.kt")
                 }
-                val iosX64 = sourceSet {
+                sourceSet {
                     name = "iosX64"
                     displayName = "iosX64"
                     analysisPlatform = "native"
@@ -149,19 +149,19 @@ class ExpectActualsTest : BaseAbstractTest() {
                 val noClass = allChildren.filter { it.name == "A" }
                 assertTrue(commonJ.size == 1) { "There can be only one [jvm, js]A page" }
                 assertTrue(
-                    commonJ.first().documentable?.sourceSets?.map { it.displayName }
+                    commonJ.first().documentables.firstOrNull()?.sourceSets?.map { it.displayName }
                         ?.containsAll(listOf("commonJ", "js", "jvm")) ?: false
                 ) { "A(jvm, js)should have commonJ, js, jvm sources" }
 
                 assertTrue(commonN1.size == 1) { "There can be only one [mingwX64, linuxX64]A page" }
                 assertTrue(
-                    commonN1.first().documentable?.sourceSets?.map { it.displayName }
+                    commonN1.first().documentables.firstOrNull()?.sourceSets?.map { it.displayName }
                         ?.containsAll(listOf("commonN1", "linuxX64", "mingwX64")) ?: false
                 ) { "[mingwX64, linuxX64]A should have commonN1, linuxX64, mingwX64 sources" }
 
                 assertTrue(commonN2.size == 1) { "There can be only one [iosX64, iosArm64]A page" }
                 assertTrue(
-                    commonN2.first().documentable?.sourceSets?.map { it.displayName }
+                    commonN2.first().documentables.firstOrNull()?.sourceSets?.map { it.displayName }
                         ?.containsAll(listOf("commonN2", "iosArm64", "iosX64")) ?: false
                 ) { "[iosX64, iosArm64]A should have commonN2, iosArm64, iosX64 sources" }
 
diff --git a/plugins/base/src/test/kotlin/filter/JavaVisibilityFilterTest.kt b/plugins/base/src/test/kotlin/filter/JavaVisibilityFilterTest.kt
index e6acec92..efab9aba 100644
--- a/plugins/base/src/test/kotlin/filter/JavaVisibilityFilterTest.kt
+++ b/plugins/base/src/test/kotlin/filter/JavaVisibilityFilterTest.kt
@@ -225,6 +225,7 @@ class JavaVisibilityFilterTest : BaseAbstractTest() {
     )
 
     companion object TestDataSources {
+        @Suppress("DEPRECATION") // for includeNonPublic
         val globalExcludes = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -234,6 +235,7 @@ class JavaVisibilityFilterTest : BaseAbstractTest() {
             }
         }
 
+        @Suppress("DEPRECATION") // for includeNonPublic
         val globalIncludes = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -243,6 +245,7 @@ class JavaVisibilityFilterTest : BaseAbstractTest() {
             }
         }
 
+        @Suppress("DEPRECATION") // for includeNonPublic
         val globalIncludesPackageExcludes = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -251,17 +254,18 @@ class JavaVisibilityFilterTest : BaseAbstractTest() {
                     perPackageOptions = mutableListOf(
                         PackageOptionsImpl(
                             "basic",
-                            false,
-                            false,
-                            false,
-                            false,
-                            DokkaDefaults.documentedVisibilities
+                            includeNonPublic = false,
+                            reportUndocumented = false,
+                            skipDeprecated = false,
+                            suppress = false,
+                            documentedVisibilities = DokkaDefaults.documentedVisibilities
                         )
                     )
                 }
             }
         }
 
+        @Suppress("DEPRECATION") // for includeNonPublic
         val globalExcludesPackageIncludes = dokkaConfiguration {
             sourceSets {
                 sourceSet {
diff --git a/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt b/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
index 3b333445..c89234f8 100644
--- a/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
+++ b/plugins/base/src/test/kotlin/filter/VisibilityFilterTest.kt
@@ -372,6 +372,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `should choose new documentedVisibilities over deprecated includeNonPublic`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -404,6 +405,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `includeNonPublic - public function with false global`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -435,6 +437,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `includeNonPublic - private function with false global`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -466,6 +469,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `includeNonPublic - private function with true global`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -497,6 +501,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `private setter with false global includeNonPublic`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -528,6 +533,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `includeNonPublic - private function with false global true package`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -569,6 +575,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `includeNonPublic - private function with true global false package`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -610,6 +617,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `includeNonPublic - private typealias should be skipped`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -636,6 +644,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `includeNonPublic - internal property from enum should be skipped`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -675,6 +684,7 @@ class VisibilityFilterTest : BaseAbstractTest() {
 
     @Test
     fun `includeNonPublic - internal property from enum`() {
+        @Suppress("DEPRECATION")
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
diff --git a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
index 3b0f6eef..1a4bb330 100644
--- a/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
+++ b/plugins/base/src/test/kotlin/linkableContent/LinkableContentTest.kt
@@ -39,7 +39,7 @@ class LinkableContentTest : BaseAbstractTest() {
                     dependentSourceSets = setOf(common.value.sourceSetID)
                     sourceRoots = listOf(Paths.get("$testDataDir/jvmAndJsSecondCommonMain/kotlin").toString())
                 }
-                val js = sourceSet {
+                sourceSet {
                     name = "js"
                     displayName = "js"
                     analysisPlatform = "js"
@@ -47,7 +47,7 @@ class LinkableContentTest : BaseAbstractTest() {
                     sourceRoots = listOf(Paths.get("$testDataDir/jsMain/kotlin").toString())
                     includes = listOf(Paths.get("$includesDir/include2.md").toString())
                 }
-                val jvm = sourceSet {
+                sourceSet {
                     name = "jvm"
                     displayName = "jvm"
                     analysisPlatform = "jvm"
@@ -91,7 +91,7 @@ class LinkableContentTest : BaseAbstractTest() {
                     dependentSourceSets = setOf(common.value.sourceSetID)
                     sourceRoots = listOf(Paths.get("$testDataDir/jvmAndJsSecondCommonMain/kotlin").toString())
                 }
-                val js = sourceSet {
+                sourceSet {
                     name = "js"
                     displayName = "js"
                     analysisPlatform = "js"
@@ -105,7 +105,7 @@ class LinkableContentTest : BaseAbstractTest() {
                         )
                     )
                 }
-                val jvm = sourceSet {
+                sourceSet {
                     name = "jvm"
                     displayName = "jvm"
                     analysisPlatform = "jvm"
@@ -165,7 +165,7 @@ class LinkableContentTest : BaseAbstractTest() {
                     dependentSourceSets = setOf(common.value.sourceSetID)
                     sourceRoots = listOf(Paths.get("$testDataDir/jvmAndJsSecondCommonMain/kotlin").toString())
                 }
-                val js = sourceSet {
+                sourceSet {
                     name = "js"
                     displayName = "js"
                     analysisPlatform = "js"
@@ -173,7 +173,7 @@ class LinkableContentTest : BaseAbstractTest() {
                     sourceRoots = listOf(Paths.get("$testDataDir/jsMain/kotlin").toString())
                     samples = listOf("$testDataDir/jsMain/resources/Samples.kt")
                 }
-                val jvm = sourceSet {
+                sourceSet {
                     name = "jvm"
                     displayName = "jvm"
                     analysisPlatform = "jvm"
@@ -192,9 +192,9 @@ class LinkableContentTest : BaseAbstractTest() {
                 Assertions.assertEquals(1, moduleChildren.size)
                 val packageChildren = moduleChildren.first().children
                 Assertions.assertEquals(2, packageChildren.size)
-                packageChildren.forEach {
-                    val name = it.name.substringBefore("Class")
-                    val classChildren = it.children
+                packageChildren.forEach { pageNode ->
+                    val name = pageNode.name.substringBefore("Class")
+                    val classChildren = pageNode.children
                     Assertions.assertEquals(2, classChildren.size)
                     val function = classChildren.find { it.name == "printWithExclamation" }
                     val text = function.cast<MemberPageNode>().content.cast<ContentGroup>().children.last()
@@ -256,7 +256,7 @@ class LinkableContentTest : BaseAbstractTest() {
                 }?.safeAs<ContentDRILink>()
 
                 Assertions.assertEquals(
-                    (sample.documentable as WithGenerics).generics.first().dri,
+                    (sample.documentables.firstOrNull() as WithGenerics).generics.first().dri,
                     returnTypeNode?.address
                 )
             }
@@ -323,7 +323,7 @@ class LinkableContentTest : BaseAbstractTest() {
                     dependentSourceSets = setOf(common.value.sourceSetID)
                     sourceRoots = listOf(Paths.get("$testDataDir/jvmAndJsSecondCommonMain/kotlin").toString())
                 }
-                val js = sourceSet {
+                sourceSet {
                     name = "js"
                     displayName = "js"
                     analysisPlatform = "js"
@@ -331,7 +331,7 @@ class LinkableContentTest : BaseAbstractTest() {
                     sourceRoots = listOf(Paths.get("$testDataDir/jsMain/kotlin").toString())
                     includes = listOf(Paths.get("$includesDir/include2.md").toString())
                 }
-                val jvm = sourceSet {
+                sourceSet {
                     name = "jvm"
                     displayName = "jvm"
                     analysisPlatform = "jvm"
@@ -346,8 +346,8 @@ class LinkableContentTest : BaseAbstractTest() {
         }
 
         testFromData(configuration) {
-            documentablesMergingStage = {
-                it.documentation.entries.single {
+            documentablesMergingStage = { module ->
+                module.documentation.entries.single {
                     it.key.displayName == "jvm"
                 }.value.run {
                     Assertions.assertNotNull(dfs {
diff --git a/plugins/base/src/test/kotlin/markdown/KDocTest.kt b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
index ac8efe6a..fddd41e7 100644
--- a/plugins/base/src/test/kotlin/markdown/KDocTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/KDocTest.kt
@@ -26,7 +26,7 @@ abstract class KDocTest : BaseAbstractTest() {
         """.trimMargin()
 
     private fun actualDocumentationNode(modulePageNode: ModulePageNode) =
-        (modulePageNode.documentable?.children?.first() as DPackage)
+        (modulePageNode.documentables.firstOrNull()?.children?.first() as DPackage)
             .classlikes.single()
             .documentation.values.single()
 
diff --git a/plugins/base/src/test/kotlin/markdown/LinkTest.kt b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
index 186fe9ee..f141bb06 100644
--- a/plugins/base/src/test/kotlin/markdown/LinkTest.kt
+++ b/plugins/base/src/test/kotlin/markdown/LinkTest.kt
@@ -74,7 +74,7 @@ class LinkTest : BaseAbstractTest() {
                 val root = rootPageNode.children.single().children.single() as ClasslikePageNode
                 val innerClass = root.children.first { it is ClasslikePageNode }
                 val foo = innerClass.children.first { it.name == "foo" } as MemberPageNode
-                val destinationDri = (root.documentable as WithGenerics).generics.first().dri.toString()
+                val destinationDri = (root.documentables.firstOrNull() as WithGenerics).generics.first().dri.toString()
 
                 assertEquals(destinationDri, "/Outer///PointingToGenericParameters(0)/")
                 assertNotNull(foo.content.dfs { it is ContentDRILink && it.address.toString() == destinationDri })
diff --git a/plugins/base/src/test/kotlin/model/CommentTest.kt b/plugins/base/src/test/kotlin/model/CommentTest.kt
index 59b1817a..6a7b2d89 100644
--- a/plugins/base/src/test/kotlin/model/CommentTest.kt
+++ b/plugins/base/src/test/kotlin/model/CommentTest.kt
@@ -72,7 +72,6 @@ class CommentTest : AbstractModelTest("/src/main/kotlin/comment/Test.kt", "comme
             |fun tst() = property
         """
         ) {
-            val p = this
             with((this / "comment" / "property").cast<DProperty>()) {
                 comments() equals ""
             }
@@ -252,85 +251,4 @@ class CommentTest : AbstractModelTest("/src/main/kotlin/comment/Test.kt", "comme
             }
         }
     }
-
-//    @Test todo
-    fun directive() {
-        inlineModelTest(
-            """
-            |/**
-            | * Summary
-            | *
-            | * @sample example1
-            | * @sample example2
-            | * @sample X.example3
-            | * @sample X.Y.example4
-            | */
-            |val property = "test"
-            |
-            |fun example1(node: String) = if (true) {
-            |    println(property)
-            |}
-            |
-            |fun example2(node: String) {
-            |    if (true) {
-            |        println(property)
-            |    }
-            |}
-            |
-            |class X {
-            |    fun example3(node: String) {
-            |        if (true) {
-            |            println(property)
-            |        }
-            |    }
-            |
-            |    class Y {
-            |        fun example4(node: String) {
-            |            if (true) {
-            |                println(property)
-            |            }
-            |        }
-            |    }
-            |}
-        """
-        ) {
-            with((this / "comment" / "property").cast<DProperty>()) {
-                this
-            }
-        }
-    }
-
-
-//    @Test fun directive() {
-//        checkSourceExistsAndVerifyModel("testdata/comments/directive.kt", defaultModelConfig) { model ->
-//            with(model.members.single().members.first()) {
-//                assertEquals("Summary", content.summary.toTestString())
-//                with (content.description) {
-//                    assertEqualsIgnoringSeparators("""
-//                        |[code lang=kotlin]
-//                        |if (true) {
-//                        |    println(property)
-//                        |}
-//                        |[/code]
-//                        |[code lang=kotlin]
-//                        |if (true) {
-//                        |    println(property)
-//                        |}
-//                        |[/code]
-//                        |[code lang=kotlin]
-//                        |if (true) {
-//                        |    println(property)
-//                        |}
-//                        |[/code]
-//                        |[code lang=kotlin]
-//                        |if (true) {
-//                        |    println(property)
-//                        |}
-//                        |[/code]
-//                        |""".trimMargin(), toTestString())
-//                }
-//            }
-//        }
-//    }
-
 }
diff --git a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
index 4b410f33..46b13763 100644
--- a/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
+++ b/plugins/base/src/test/kotlin/pageMerger/PageNodeMergerTest.kt
@@ -137,14 +137,14 @@ class PageNodeMergerTest : BaseAbstractTest() {
                     analysisPlatform = "common"
                     sourceRoots = listOf("src/commonMain/kotlin/pageMerger/Test.kt")
                 }
-                val js = sourceSet {
+                sourceSet {
                     name = "js"
                     displayName = "js"
                     analysisPlatform = "js"
                     dependentSourceSets = setOf(common.value.sourceSetID)
                     sourceRoots = listOf("src/jsMain/kotlin/pageMerger/Test.kt")
                 }
-                val jvm = sourceSet {
+                sourceSet {
                     name = "jvm"
                     displayName = "jvm"
                     analysisPlatform = "jvm"
@@ -178,10 +178,10 @@ class PageNodeMergerTest : BaseAbstractTest() {
                 val jsClass = allChildren.filter { it.name == "[js]DoNotMerge" }
                 val noClass = allChildren.filter { it.name == "DoNotMerge" }
                 assertTrue(jvmClass.size == 1) { "There can be only one DoNotMerge(jvm) page" }
-                assertTrue(jvmClass.first().documentable?.sourceSets?.single()?.analysisPlatform?.key == "jvm") { "[jvm]DoNotMerge should have only jvm sources" }
+                assertTrue(jvmClass.first().documentables.firstOrNull()?.sourceSets?.single()?.analysisPlatform?.key == "jvm") { "[jvm]DoNotMerge should have only jvm sources" }
 
                 assertTrue(jsClass.size == 1) { "There can be only one DoNotMerge(js) page" }
-                assertTrue(jsClass.first().documentable?.sourceSets?.single()?.analysisPlatform?.key == "js") { "[js]DoNotMerge should have only js sources" }
+                assertTrue(jsClass.first().documentables.firstOrNull()?.sourceSets?.single()?.analysisPlatform?.key == "js") { "[js]DoNotMerge should have only js sources" }
 
                 assertTrue(noClass.isEmpty()) { "There can't be any DoNotMerge page" }
             }
diff --git a/plugins/base/src/test/kotlin/renderers/html/FormattingUtilsTest.kt b/plugins/base/src/test/kotlin/renderers/html/FormattingUtilsTest.kt
index c77a78fb..3e5ceb75 100644
--- a/plugins/base/src/test/kotlin/renderers/html/FormattingUtilsTest.kt
+++ b/plugins/base/src/test/kotlin/renderers/html/FormattingUtilsTest.kt
@@ -1,11 +1,11 @@
 package renderers.html
 
-import junit.framework.Assert.assertEquals
 import kotlinx.html.body
 import kotlinx.html.html
 import kotlinx.html.stream.createHTML
 import org.jetbrains.dokka.base.renderers.html.buildBreakableText
 import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
 
 class FormattingUtilsTest {
     @Test
diff --git a/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt b/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
index 8a8586ee..989b82ef 100644
--- a/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
+++ b/plugins/base/src/test/kotlin/resourceLinks/ResourceLinksTest.kt
@@ -63,7 +63,7 @@ class ResourceLinksTest : BaseAbstractTest() {
             configuration,
             pluginOverrides = listOf(TestResourcesAppenderPlugin(absoluteResources + relativeResources), writerPlugin)
         ) {
-            renderingStage = { root, context ->
+            renderingStage = { _, _ ->
                 Jsoup
                     .parse(writerPlugin.writer.contents.getValue("root/example.html"))
                     .head()
@@ -114,7 +114,7 @@ class ResourceLinksTest : BaseAbstractTest() {
             configuration,
             pluginOverrides = listOf(writerPlugin)
         ) {
-            renderingStage = { root, context ->
+            renderingStage = { _, _ ->
                 run {
                     if (isMultiModule) {
                         assertNull(writerPlugin.writer.contents["images/customImage.svg"])
@@ -179,7 +179,7 @@ class ResourceLinksTest : BaseAbstractTest() {
             configuration,
             pluginOverrides = listOf(TestResourcesAppenderPlugin(absoluteResources + relativeResources), writerPlugin)
         ) {
-            renderingStage = { root, context ->
+            renderingStage = { _, _ ->
                 run {
                     assertNull(writerPlugin.writer.contents["scripts/relativePath.js"])
                     assertNull(writerPlugin.writer.contents["styles/relativePath.js"])
diff --git a/plugins/base/src/test/kotlin/signatures/AbstractRenderingTest.kt b/plugins/base/src/test/kotlin/signatures/AbstractRenderingTest.kt
index 65ac1224..e7f408f2 100644
--- a/plugins/base/src/test/kotlin/signatures/AbstractRenderingTest.kt
+++ b/plugins/base/src/test/kotlin/signatures/AbstractRenderingTest.kt
@@ -27,14 +27,14 @@ abstract class AbstractRenderingTest : BaseAbstractTest() {
                 dependentSourceSets = setOf(common.value.sourceSetID)
                 sourceRoots = listOf(Paths.get("$testDataDir/jvmAndJsSecondCommonMain/kotlin").toString())
             }
-            val js = sourceSet {
+            sourceSet {
                 name = "js"
                 displayName = "js"
                 analysisPlatform = "js"
                 dependentSourceSets = setOf(common.value.sourceSetID, jvmAndJsSecondCommonMain.value.sourceSetID)
                 sourceRoots = listOf(Paths.get("$testDataDir/jsMain/kotlin").toString())
             }
-            val jvm = sourceSet {
+            sourceSet {
                 name = "jvm"
                 displayName = "jvm"
                 analysisPlatform = "jvm"
diff --git a/plugins/base/src/test/kotlin/transformers/MergeImplicitExpectActualDeclarationsTest.kt b/plugins/base/src/test/kotlin/transformers/MergeImplicitExpectActualDeclarationsTest.kt
index ad3b5d38..33ec2372 100644
--- a/plugins/base/src/test/kotlin/transformers/MergeImplicitExpectActualDeclarationsTest.kt
+++ b/plugins/base/src/test/kotlin/transformers/MergeImplicitExpectActualDeclarationsTest.kt
@@ -134,10 +134,10 @@ class MergeImplicitExpectActualDeclarationsTest : BaseAbstractTest() {
                 assertNotNull(classPage, "Tested class not found!")
 
                 val props = classPage.findSectionWithName("Properties").assertNotNull("Properties")
-                val prop1 = props.children.singleOrNull().assertNotNull("prop1")
+                props.children.singleOrNull().assertNotNull("prop1")
 
                 val functions = classPage.findSectionWithName("Functions").assertNotNull("Functions")
-                val method1 = functions.children.singleOrNull().assertNotNull("method1")
+                functions.children.singleOrNull().assertNotNull("method1")
             }
         }
     }
@@ -218,7 +218,7 @@ class MergeImplicitExpectActualDeclarationsTest : BaseAbstractTest() {
                 assertNotNull(classPage, "Tested class not found!")
 
                 val entries = classPage.findSectionWithName("Entries").assertNotNull("Entries")
-                val entry = entries.children.singleOrNull().assertNotNull("ENTRY")
+                entries.children.singleOrNull().assertNotNull("ENTRY")
 
                 val props = classPage.findSectionWithName("Properties").assertNotNull("Properties")
                 assertEquals(
diff --git a/plugins/base/src/test/kotlin/translators/DefaultDescriptorToDocumentableTranslatorTest.kt b/plugins/base/src/test/kotlin/translators/DefaultDescriptorToDocumentableTranslatorTest.kt
index fd9fcc5d..79e9f548 100644
--- a/plugins/base/src/test/kotlin/translators/DefaultDescriptorToDocumentableTranslatorTest.kt
+++ b/plugins/base/src/test/kotlin/translators/DefaultDescriptorToDocumentableTranslatorTest.kt
@@ -185,48 +185,50 @@ class DefaultDescriptorToDocumentableTranslatorTest : BaseAbstractTest() {
         classlikes.zip(testSuites).forEach { (classlike, testSuites) ->
             testSuites.forEach { testSuite ->
                 when (testSuite) {
-                    is TestSuite.PropertyDoesntExist -> Assert.assertEquals(
-                        "Test for class ${classlike.name} failed",
+                    is TestSuite.PropertyDoesntExist -> assertEquals(
                         null,
-                        classlike.properties.firstOrNull { it.name == testSuite.propertyName })
+                        classlike.properties.firstOrNull { it.name == testSuite.propertyName },
+                        "Test for class ${classlike.name} failed"
+                    )
                     is TestSuite.PropertyExists -> classlike.properties.single { it.name == testSuite.propertyName }
                         .run {
-                            Assert.assertEquals(
-                                "Test for class ${classlike.name} with property $name failed",
+                            assertEquals(
                                 testSuite.modifier,
-                                modifier.values.single()
+                                modifier.values.single(),
+                                "Test for class ${classlike.name} with property $name failed"
                             )
-                            Assert.assertEquals(
-                                "Test for class ${classlike.name} with property $name failed",
+                            assertEquals(
                                 testSuite.visibility,
-                                visibility.values.single()
+                                visibility.values.single(),
+                                "Test for class ${classlike.name} with property $name failed"
                             )
-                            Assert.assertEquals(
-                                "Test for class ${classlike.name} with property $name failed",
+                            assertEquals(
                                 testSuite.additionalModifiers,
-                                extra[AdditionalModifiers]?.content?.values?.single()
+                                extra[AdditionalModifiers]?.content?.values?.single(),
+                                "Test for class ${classlike.name} with property $name failed"
                             )
                         }
-                    is TestSuite.FunctionDoesntExist -> Assert.assertEquals(
-                        "Test for class ${classlike.name} failed",
+                    is TestSuite.FunctionDoesntExist -> assertEquals(
                         null,
-                        classlike.functions.firstOrNull { it.name == testSuite.propertyName })
+                        classlike.functions.firstOrNull { it.name == testSuite.propertyName },
+                        "Test for class ${classlike.name} failed"
+                    )
                     is TestSuite.FunctionExists -> classlike.functions.single { it.name == testSuite.propertyName }
                         .run {
-                            Assert.assertEquals(
-                                "Test for class ${classlike.name} with function $name failed",
+                            assertEquals(
                                 testSuite.modifier,
-                                modifier.values.single()
+                                modifier.values.single(),
+                                "Test for class ${classlike.name} with function $name failed"
                             )
-                            Assert.assertEquals(
-                                "Test for class ${classlike.name} with function $name failed",
+                            assertEquals(
                                 testSuite.visibility,
-                                visibility.values.single()
+                                visibility.values.single(),
+                                "Test for class ${classlike.name} with function $name failed"
                             )
-                            Assert.assertEquals(
-                                "Test for class ${classlike.name} with function $name failed",
+                            assertEquals(
                                 testSuite.additionalModifiers,
-                                extra[AdditionalModifiers]?.content?.values?.single()
+                                extra[AdditionalModifiers]?.content?.values?.single(),
+                                "Test for class ${classlike.name} with function $name failed"
                             )
                         }
                 }
@@ -481,6 +483,7 @@ class DefaultDescriptorToDocumentableTranslatorTest : BaseAbstractTest() {
     @Test
     fun `derived properties with only public code`() {
 
+        @Suppress("DEPRECATION") // for includeNonPublic
         val configuration = dokkaConfiguration {
             sourceSets {
                 sourceSet {
@@ -666,6 +669,7 @@ class DefaultDescriptorToDocumentableTranslatorTest : BaseAbstractTest() {
         }
     }
 
+    @Suppress("DEPRECATION") // for includeNonPublic
     val javaConfiguration = dokkaConfiguration {
         sourceSets {
             sourceSet {
diff --git a/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt b/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
index 9f74e219..1213727d 100644
--- a/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
+++ b/plugins/base/src/test/kotlin/translators/DefaultPsiToDocumentableTranslatorTest.kt
@@ -14,6 +14,7 @@ import org.junit.jupiter.api.Test
 import utils.assertNotNull
 
 class DefaultPsiToDocumentableTranslatorTest : BaseAbstractTest() {
+    @Suppress("DEPRECATION") // for includeNonPublic
     val configuration = dokkaConfiguration {
         sourceSets {
             sourceSet {
diff --git a/plugins/base/src/test/kotlin/translators/JavadocInheritedDocTagsTest.kt b/plugins/base/src/test/kotlin/translators/JavadocInheritedDocTagsTest.kt
index ecde2c77..7510e541 100644
--- a/plugins/base/src/test/kotlin/translators/JavadocInheritedDocTagsTest.kt
+++ b/plugins/base/src/test/kotlin/translators/JavadocInheritedDocTagsTest.kt
@@ -12,6 +12,7 @@ import org.jetbrains.dokka.model.doc.Deprecated as DokkaDeprecatedTag
 import org.jetbrains.dokka.model.doc.Throws as DokkaThrowsTag
 
 class JavadocInheritedDocTagsTest : BaseAbstractTest() {
+    @Suppress("DEPRECATION") // for includeNonPublic
     private val configuration = dokkaConfiguration {
         sourceSets {
             sourceSet {
diff --git a/plugins/gfm/src/main/kotlin/org/jetbrains/dokka/gfm/renderer/CommonmarkRenderer.kt b/plugins/gfm/src/main/kotlin/org/jetbrains/dokka/gfm/renderer/CommonmarkRenderer.kt
index 786e410d..13322944 100644
--- a/plugins/gfm/src/main/kotlin/org/jetbrains/dokka/gfm/renderer/CommonmarkRenderer.kt
+++ b/plugins/gfm/src/main/kotlin/org/jetbrains/dokka/gfm/renderer/CommonmarkRenderer.kt
@@ -99,15 +99,20 @@ open class CommonmarkRenderer(
         pageContext: ContentPage,
         sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
-        locationProvider.resolve(node.address, node.sourceSets, pageContext)?.let {
-            buildLink(it) {
+        val location = locationProvider.resolve(node.address, node.sourceSets, pageContext)
+        if (location == null) {
+            if (isPartial) {
+                templateCommand(ResolveLinkGfmCommand(node.address)) {
+                    buildText(node.children, pageContext, sourceSetRestriction)
+                }
+            } else {
                 buildText(node.children, pageContext, sourceSetRestriction)
             }
-        } ?: if (isPartial) {
-            templateCommand(ResolveLinkGfmCommand(node.address)) {
+        } else {
+            buildLink(location) {
                 buildText(node.children, pageContext, sourceSetRestriction)
             }
-        } else buildText(node.children, pageContext, sourceSetRestriction)
+        }
     }
 
     override fun StringBuilder.buildLineBreak() {
@@ -253,11 +258,11 @@ open class CommonmarkRenderer(
     override fun StringBuilder.buildDivergent(node: ContentDivergentGroup, pageContext: ContentPage) {
 
         val distinct =
-            node.groupDivergentInstances(pageContext, { instance, contentPage, sourceSet ->
+            node.groupDivergentInstances(pageContext, { instance, _, sourceSet ->
                 instance.before?.let { before ->
                     buildString { buildContentNode(before, pageContext, sourceSet) }
                 } ?: ""
-            }, { instance, contentPage, sourceSet ->
+            }, { instance, _, sourceSet ->
                 instance.after?.let { after ->
                     buildString { buildContentNode(after, pageContext, sourceSet) }
                 } ?: ""
diff --git a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPageCreator.kt b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPageCreator.kt
index 61d45ae1..a79c6b20 100644
--- a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPageCreator.kt
+++ b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/JavadocPageCreator.kt
@@ -37,9 +37,12 @@ open class JavadocPageCreator(context: DokkaContext) {
             p.classlikes.mapNotNull { pageForClasslike(it) }
         )
 
-    fun pageForClasslike(c: DClasslike): JavadocClasslikePageNode? =
-        c.highestJvmSourceSet?.let { jvm ->
+    fun pageForClasslike(c: DClasslike): JavadocClasslikePageNode? {
+        return c.highestJvmSourceSet?.let { jvm ->
+            @Suppress("UNCHECKED_CAST")
+            val extra = ((c as? WithExtraProperties<Documentable>)?.extra ?: PropertyContainer.empty())
             val children = c.classlikes.mapNotNull { pageForClasslike(it) }
+
             JavadocClasslikePageNode(
                 name = c.dri.classNames.orEmpty(),
                 content = contentForClasslike(c),
@@ -70,10 +73,10 @@ open class JavadocPageCreator(context: DokkaContext) {
                 },
                 documentables = listOf(c),
                 children = children,
-                extra = ((c as? WithExtraProperties<Documentable>)?.extra
-                    ?: PropertyContainer.empty()) + c.indexesInDocumentation()
+                extra = extra + c.indexesInDocumentation()
             )
         }
+    }
 
     private fun contentForModule(m: DModule): JavadocContentNode =
         JavadocContentGroup(
diff --git a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/pages/htmlPreprocessors.kt b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/pages/htmlPreprocessors.kt
index bef4108c..057b9e85 100644
--- a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/pages/htmlPreprocessors.kt
+++ b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/pages/htmlPreprocessors.kt
@@ -39,12 +39,13 @@ object TreeViewInstaller : PageTransformer {
             root = root
         )
 
-        return node.modified(children = node.children.map { node ->
+        val nodeChildren = node.children.map { childNode ->
             install(
-                node,
+                childNode,
                 root
             )
-        } + overviewTree) as JavadocModulePageNode
+        }
+        return node.modified(children = nodeChildren + overviewTree) as JavadocModulePageNode
     }
 
     private fun installPackageTreeNode(node: JavadocPackagePageNode, root: RootPageNode): JavadocPackagePageNode {
diff --git a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/renderer/KorteJavadocRenderer.kt b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/renderer/KorteJavadocRenderer.kt
index 1d721611..f8377e41 100644
--- a/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/renderer/KorteJavadocRenderer.kt
+++ b/plugins/javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/renderer/KorteJavadocRenderer.kt
@@ -11,7 +11,6 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.renderers.OutputWriter
-import org.jetbrains.dokka.base.resolvers.local.LocationProvider
 import org.jetbrains.dokka.javadoc.JavadocPlugin
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.pages.*
@@ -136,7 +135,9 @@ class KorteJavadocRenderer(val context: DokkaContext, resourceDir: String) :
                 )
             },
             TeFunction("createPackageHierarchy") { args ->
+                @Suppress("UNCHECKED_CAST")
                 val list = args.first() as List<JavadocPackagePageNode>
+
                 list.mapIndexed { i, p ->
                     val content = if (i + 1 == list.size) "" else ", "
                     val name = p.name
@@ -144,6 +145,7 @@ class KorteJavadocRenderer(val context: DokkaContext, resourceDir: String) :
                 }.joinToString("\n")
             },
             TeFunction("renderInheritanceGraph") { args ->
+                @Suppress("UNCHECKED_CAST")
                 val rootNodes = args.first() as List<TreeViewPage.InheritanceNode>
 
                 fun drawRec(node: TreeViewPage.InheritanceNode): String =
diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt
index 10240a3f..0f8d7e79 100644
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt
+++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocClasslikeTemplateMapTest.kt
@@ -351,8 +351,10 @@ internal class JavadocClasslikeTemplateMapTest : AbstractJavadocTemplateMapTest(
 
     private fun Map<String, Any?>.signatureWithModifiers(): String = "${modifiers()} ${signatureWithoutModifiers()}"
 
+    @Suppress("UNCHECKED_CAST")
     private fun Map<String, Any?>.signatureWithoutModifiers(): String = (get("signature") as Map<String, Any?>)["signatureWithoutModifiers"] as String
 
+    @Suppress("UNCHECKED_CAST")
     private fun Map<String, Any?>.modifiers(): String = (get("signature") as Map<String, Any?>)["modifiers"] as String
 
 }
diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocDeprecatedTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocDeprecatedTest.kt
index 982d356a..e2331f58 100644
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocDeprecatedTest.kt
+++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocDeprecatedTest.kt
@@ -10,6 +10,7 @@ internal class JavadocDeprecatedTest : AbstractJavadocTemplateMapTest() {
     @Test
     fun `generates correct number of sections`() {
         testDeprecatedPageTemplateMaps { templateMap ->
+            @Suppress("UNCHECKED_CAST")
             Assertions.assertEquals(6, (templateMap["sections"] as List<TemplateMap>).size)
         }
     }
@@ -164,9 +165,11 @@ internal class JavadocDeprecatedTest : AbstractJavadocTemplateMapTest() {
             operation(firstPageOfType<DeprecatedPage>().templateMap)
         }
 
+    @Suppress("UNCHECKED_CAST")
     private fun TemplateMap.section(name: String) =
         (this["sections"] as List<TemplateMap>).first { it["caption"] == name }
 
+    @Suppress("UNCHECKED_CAST")
     private fun TemplateMap.elements() =
         this["elements"] as List<TemplateMap>
 }
\ No newline at end of file
diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocIndexTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocIndexTest.kt
index 801213c2..76c345b0 100644
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocIndexTest.kt
+++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocIndexTest.kt
@@ -28,6 +28,7 @@ internal class JavadocIndexTest : AbstractJavadocTemplateMapTest() {
     @Test
     fun `templateMap for class index`() {
         testIndexPagesTemplateMaps { templateMaps ->
+            @Suppress("UNCHECKED_CAST")
             val element = (templateMaps[2]["elements"] as List<TemplateMap>)[1]
             assertEquals("../package0/ClassA.html", element["address"])
             assertEquals("ClassA", element["name"])
@@ -41,6 +42,7 @@ internal class JavadocIndexTest : AbstractJavadocTemplateMapTest() {
     @Test
     fun `templateMap for enum entry index`() {
         testIndexPagesTemplateMaps { templateMaps ->
+            @Suppress("UNCHECKED_CAST")
             val element = (templateMaps[0]["elements"] as List<TemplateMap>).last()
             assertEquals("../package1/ClassCEnum.html#A", element["address"])
             assertEquals("A", element["name"])
@@ -54,6 +56,7 @@ internal class JavadocIndexTest : AbstractJavadocTemplateMapTest() {
     @Test
     fun `templateMap for function index`() {
         testIndexPagesTemplateMaps { templateMaps ->
+            @Suppress("UNCHECKED_CAST")
             val element = (templateMaps[0]["elements"] as List<TemplateMap>).first()
             assertEquals("../package0/ClassA.html#a()", element["address"])
             assertEquals("a()", element["name"])
diff --git a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocPackageTemplateMapTest.kt b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocPackageTemplateMapTest.kt
index 356e5772..592d7b0d 100644
--- a/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocPackageTemplateMapTest.kt
+++ b/plugins/javadoc/src/test/kotlin/org/jetbrains/dokka/javadoc/JavadocPackageTemplateMapTest.kt
@@ -13,6 +13,7 @@ import java.io.File
 internal class JavadocPackageTemplateMapTest : AbstractJavadocTemplateMapTest() {
 
     @Test
+    @Suppress("UNCHECKED_CAST")
     fun `single class`() {
         dualTestTemplateMapInline(
             kotlin =
@@ -44,6 +45,7 @@ internal class JavadocPackageTemplateMapTest : AbstractJavadocTemplateMapTest()
     }
 
     @Test
+    @Suppress("UNCHECKED_CAST")
     fun `multiple packages`() {
         dualTestTemplateMapInline(
             kotlin =
diff --git a/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt b/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt
index fa1f668f..1f5719ea 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/signatures/JavaSignatureProvider.kt
@@ -52,19 +52,23 @@ class JavaSignatureProvider internal constructor(ctcc: CommentsToContentConverte
         }
 
     private fun signature(c: DClasslike) =
-        c.sourceSets.map {
+        c.sourceSets.map { sourceSet ->
+            @Suppress("UNCHECKED_CAST")
+            val deprecationStyles = (c as? WithExtraProperties<out Documentable>)
+                ?.stylesIfDeprecated(sourceSet)
+                ?: emptySet()
+
             contentBuilder.contentFor(
                 c,
                 ContentKind.Symbol,
-                setOf(TextStyle.Monospace) + ((c as? WithExtraProperties<out Documentable>)?.stylesIfDeprecated(it)
-                    ?: emptySet()),
-                sourceSets = setOf(it)
+                setOf(TextStyle.Monospace) + deprecationStyles,
+                sourceSets = setOf(sourceSet)
             ) {
-                c.visibility[it]?.takeIf { it !in ignoredVisibilities }?.name?.plus(" ")?.let { keyword(it) }
+                c.visibility[sourceSet]?.takeIf { it !in ignoredVisibilities }?.name?.plus(" ")?.let { keyword(it) }
 
                 if (c is DClass) {
-                    c.modifier[it]?.takeIf { it !in ignoredModifiers }?.name?.plus(" ")?.let { keyword(it) }
-                    c.modifiers()[it]?.toSignatureString()?.let { keyword(it) }
+                    c.modifier[sourceSet]?.takeIf { it !in ignoredModifiers }?.name?.plus(" ")?.let { keyword(it) }
+                    c.modifiers()[sourceSet]?.toSignatureString()?.let { keyword(it) }
                 }
 
                 when (c) {
diff --git a/plugins/kotlin-as-java/src/main/kotlin/transformers/JvmNameDocumentableTransformer.kt b/plugins/kotlin-as-java/src/main/kotlin/transformers/JvmNameDocumentableTransformer.kt
index 28cb3453..d937c841 100644
--- a/plugins/kotlin-as-java/src/main/kotlin/transformers/JvmNameDocumentableTransformer.kt
+++ b/plugins/kotlin-as-java/src/main/kotlin/transformers/JvmNameDocumentableTransformer.kt
@@ -12,8 +12,8 @@ class JvmNameDocumentableTransformer : DocumentableTransformer {
         return original.copy(packages = original.packages.map { transform(it, context) })
     }
 
-    internal fun <T : Documentable> transform(documentable: T, context: DokkaContext): T =
-        with(documentable) {
+    internal fun <T : Documentable> transform(documentable: T, context: DokkaContext): T {
+        val transformResult = with(documentable) {
             when (this) {
                 is DPackage -> copy(
                     functions = functions.map { transform(it, context) },
@@ -40,7 +40,10 @@ class JvmNameDocumentableTransformer : DocumentableTransformer {
                     this
                 }
             }
-        } as T
+        }
+        @Suppress("UNCHECKED_CAST")
+        return transformResult as T
+    }
 
     private fun PropertyContainer<DFunction>.withoutJvmName(): PropertyContainer<DFunction> {
         val annotationsWithoutJvmName = get(Annotations)?.let { annotations ->
diff --git a/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToNavigationCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToNavigationCommandResolutionTest.kt
new file mode 100644
index 00000000..81d39752
--- /dev/null
+++ b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToNavigationCommandResolutionTest.kt
@@ -0,0 +1,137 @@
+package org.jetbrains.dokka.templates
+
+import kotlinx.html.a
+import kotlinx.html.div
+import kotlinx.html.id
+import kotlinx.html.span
+import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.DokkaModuleDescriptionImpl
+import org.jetbrains.dokka.base.renderers.html.templateCommand
+import org.jetbrains.dokka.base.templating.AddToNavigationCommand
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.junit.Rule
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+import org.junit.rules.TemporaryFolder
+import utils.assertHtmlEqualsIgnoringWhitespace
+
+class AddToNavigationCommandResolutionTest : TemplatingAbstractTest() {
+    @get:Rule
+    val folder: TemporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `should substitute AddToNavigationCommand in root directory`() =
+        addToNavigationTest {
+            val output = folder.root.resolve("navigation.html").readText()
+            val expected = expectedOutput(
+                ModuleWithPrefix("module1"),
+                ModuleWithPrefix("module2")
+            )
+            assertHtmlEqualsIgnoringWhitespace(expected, output)
+        }
+
+    @ParameterizedTest
+    @ValueSource(strings = ["module1", "module2"])
+    fun `should substitute AddToNavigationCommand in modules directory`(moduleName: String) =
+        addToNavigationTest {
+            val output = folder.root.resolve(moduleName).resolve("navigation.html").readText()
+            val expected = expectedOutput(
+                ModuleWithPrefix("module1", ".."),
+                ModuleWithPrefix("module2", "..")
+            )
+            assertHtmlEqualsIgnoringWhitespace(expected, output)
+        }
+
+    private fun expectedOutput(vararg modulesWithPrefix: ModuleWithPrefix) = createHTML(prettyPrint = true)
+        .div("sideMenu") {
+            modulesWithPrefix.forEach { (moduleName, prefix) ->
+                val relativePrefix = prefix?.let { "$it/" } ?: ""
+                div("sideMenuPart") {
+                    id = "$moduleName-nav-submenu"
+                    div("overview") {
+                        a {
+                            href = "$relativePrefix$moduleName/module-page.html"
+                            span {
+                                +"module-$moduleName"
+                            }
+                        }
+                    }
+                    div("sideMenuPart") {
+                        id = "$moduleName-nav-submenu-0"
+                        div("overview") {
+                            a {
+                                href = "$relativePrefix$moduleName/$moduleName/package-page.html"
+                                span {
+                                    +"package-$moduleName"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    private fun inputForModule(moduleName: String) = createHTML()
+        .templateCommand(AddToNavigationCommand(moduleName)) {
+            div("sideMenuPart") {
+                id = "$moduleName-nav-submenu"
+                div("overview") {
+                    a {
+                        href = "module-page.html"
+                        span {
+                            +"module-$moduleName"
+                        }
+                    }
+                }
+                div("sideMenuPart") {
+                    id = "$moduleName-nav-submenu-0"
+                    div("overview") {
+                        a {
+                            href = "$moduleName/package-page.html"
+                            span {
+                                +"package-$moduleName"
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+    private fun addToNavigationTest(test: (DokkaContext) -> Unit) {
+        folder.create()
+        val module1 = folder.newFolder("module1")
+        val module2 = folder.newFolder("module2")
+
+        val configuration = dokkaConfiguration {
+            modules = listOf(
+                DokkaModuleDescriptionImpl(
+                    name = "module1",
+                    relativePathToOutputDirectory = module1,
+                    includes = emptySet(),
+                    sourceOutputDirectory = module1,
+                ),
+                DokkaModuleDescriptionImpl(
+                    name = "module2",
+                    relativePathToOutputDirectory = module2,
+                    includes = emptySet(),
+                    sourceOutputDirectory = module2,
+                ),
+            )
+            this.outputDir = folder.root
+        }
+
+        val module1Navigation = module1.resolve("navigation.html")
+        module1Navigation.writeText(inputForModule("module1"))
+        val module2Navigation = module2.resolve("navigation.html")
+        module2Navigation.writeText(inputForModule("module2"))
+
+        testFromData(configuration, useOutputLocationFromConfig = true) {
+            finishProcessingSubmodules = { ctx ->
+                test(ctx)
+            }
+        }
+    }
+
+    private data class ModuleWithPrefix(val moduleName: String, val prefix: String? = null)
+}
diff --git a/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToSearchCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToSearchCommandResolutionTest.kt
new file mode 100644
index 00000000..45c70469
--- /dev/null
+++ b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToSearchCommandResolutionTest.kt
@@ -0,0 +1,83 @@
+package org.jetbrains.dokka.templates
+
+import org.jetbrains.dokka.DokkaModuleDescriptionImpl
+import org.jetbrains.dokka.base.renderers.html.SearchRecord
+import org.jetbrains.dokka.base.templating.AddToSearch
+import org.jetbrains.dokka.base.templating.parseJson
+import org.jetbrains.dokka.base.templating.toJsonString
+import org.junit.Rule
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+import org.junit.rules.TemporaryFolder
+import java.io.File
+import kotlin.test.assertEquals
+
+class AddToSearchCommandResolutionTest : TemplatingAbstractTest() {
+    companion object {
+        val elements = listOf(
+            SearchRecord(name = "name1", location = "location1"),
+            SearchRecord(name = "name2", location = "location2")
+        )
+        val fromModule1 = AddToSearch(
+            moduleName = "module1",
+            elements = elements
+        )
+        val fromModule2 = AddToSearch(
+            moduleName = "module2",
+            elements = elements
+        )
+    }
+
+    @get:Rule
+    val folder: TemporaryFolder = TemporaryFolder()
+
+    @ParameterizedTest
+    @ValueSource(strings = ["pages.json"])
+    fun `should merge navigation templates`(fileName: String) {
+        setupTestDirectoriesWithContent(fileName)
+
+        val outputDir = folder.root
+        val configuration = dokkaConfiguration {
+            modules = listOf(
+                DokkaModuleDescriptionImpl(
+                    name = "module1",
+                    relativePathToOutputDirectory = folder.root.resolve("module1"),
+                    includes = emptySet(),
+                    sourceOutputDirectory = folder.root.resolve("module1"),
+                ),
+                DokkaModuleDescriptionImpl(
+                    name = "module2",
+                    relativePathToOutputDirectory = folder.root.resolve("module2"),
+                    includes = emptySet(),
+                    sourceOutputDirectory = folder.root.resolve("module2"),
+                ),
+            )
+            this.outputDir = outputDir
+        }
+
+        testFromData(configuration, useOutputLocationFromConfig = true) {
+            finishProcessingSubmodules = { _ ->
+                val expected = elements.map { it.copy(location = "module1/${it.location}") } +
+                        elements.map { it.copy(location = "module2/${it.location}") }
+
+                val output =
+                    parseJson<List<SearchRecord>>(outputDir.resolve("scripts/${fileName}").readText())
+                assertEquals(expected, output.sortedBy { it.location })
+            }
+        }
+    }
+
+    private fun setupTestDirectoriesWithContent(fileName: String): List<File> {
+        folder.create()
+        val scriptsForModule1 = folder.newFolder("module1", "scripts")
+        val scriptsForModule2 = folder.newFolder("module2", "scripts")
+        folder.newFolder("scripts")
+
+        val module1Navigation = scriptsForModule1.resolve(fileName)
+        module1Navigation.writeText(toJsonString(fromModule1))
+        val module2Navigation = scriptsForModule2.resolve(fileName)
+        module2Navigation.writeText(toJsonString(fromModule2))
+
+        return listOf(module1Navigation, module2Navigation)
+    }
+}
diff --git a/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/SubstitutionCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/SubstitutionCommandResolutionTest.kt
new file mode 100644
index 00000000..c31f63c7
--- /dev/null
+++ b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/SubstitutionCommandResolutionTest.kt
@@ -0,0 +1,111 @@
+package org.jetbrains.dokka.templates
+
+import kotlinx.html.a
+import kotlinx.html.div
+import kotlinx.html.id
+import kotlinx.html.span
+import kotlinx.html.stream.createHTML
+import org.jetbrains.dokka.DokkaModuleDescriptionImpl
+import org.jetbrains.dokka.base.renderers.html.templateCommand
+import org.jetbrains.dokka.base.renderers.html.templateCommandAsHtmlComment
+import org.jetbrains.dokka.base.templating.PathToRootSubstitutionCommand
+import org.junit.Rule
+import org.junit.jupiter.api.Test
+import org.junit.rules.TemporaryFolder
+import utils.assertHtmlEqualsIgnoringWhitespace
+import java.io.File
+
+class SubstitutionCommandResolutionTest : TemplatingAbstractTest() {
+
+    @get:Rule
+    val folder: TemporaryFolder = TemporaryFolder()
+
+    @Test
+    fun `should handle PathToRootCommand`() {
+        val template = createHTML()
+            .templateCommand(PathToRootSubstitutionCommand(pattern = "###", default = "default")) {
+                a {
+                    href = "###index.html"
+                    div {
+                        id = "logo"
+                    }
+                }
+            }
+
+        val expected = createHTML().a {
+            href = "../index.html"
+            div {
+                id = "logo"
+            }
+        }
+        checkSubstitutedResult(template, expected)
+    }
+
+    @Test
+    fun `should handle PathToRootCommand as HTML comment`() {
+        val template = createHTML().span {
+            templateCommandAsHtmlComment(PathToRootSubstitutionCommand(pattern = "###", default = "default")) {
+                this@span.a {
+                    href = "###index.html"
+                    div {
+                        id = "logo"
+                    }
+                }
+                templateCommandAsHtmlComment(PathToRootSubstitutionCommand(pattern = "####", default = "default")) {
+                    this@span.a {
+                        href = "####index.html"
+                        div {
+                            id = "logo"
+                        }
+                    }
+                }
+            }
+        }
+
+        val expected = createHTML().span {
+            a {
+                href = "../index.html"
+                div {
+                    id = "logo"
+                }
+            }
+            a {
+                href = "../index.html"
+                div {
+                    id = "logo"
+                }
+            }
+        }
+        checkSubstitutedResult(template, expected)
+    }
+
+    private fun createDirectoriesAndWriteContent(content: String): File {
+        folder.create()
+        val module1 = folder.newFolder("module1")
+        val module1Content = module1.resolve("index.html")
+        module1Content.writeText(content)
+        return module1Content
+    }
+
+    private fun checkSubstitutedResult(template: String, expected:String) {
+        val testedFile = createDirectoriesAndWriteContent(template)
+
+        val configuration = dokkaConfiguration {
+            modules = listOf(
+                DokkaModuleDescriptionImpl(
+                    name = "module1",
+                    relativePathToOutputDirectory = folder.root.resolve("module1"),
+                    includes = emptySet(),
+                    sourceOutputDirectory = folder.root.resolve("module1"),
+                )
+            )
+            this.outputDir = folder.root
+        }
+
+        testFromData(configuration, useOutputLocationFromConfig = true){
+            finishProcessingSubmodules = {
+                assertHtmlEqualsIgnoringWhitespace(expected, testedFile.readText())
+            }
+        }
+    }
+}
diff --git a/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TemplatingDokkaTestGenerator.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TemplatingDokkaTestGenerator.kt
new file mode 100644
index 00000000..50a68efb
--- /dev/null
+++ b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TemplatingDokkaTestGenerator.kt
@@ -0,0 +1,69 @@
+package org.jetbrains.dokka.templates
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.DokkaConfiguration
+import org.jetbrains.dokka.DokkaGenerator
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.testApi.logger.TestLogger
+import org.jetbrains.dokka.testApi.testRunner.AbstractTest
+import org.jetbrains.dokka.testApi.testRunner.DokkaTestGenerator
+import org.jetbrains.dokka.testApi.testRunner.TestBuilder
+import org.jetbrains.dokka.testApi.testRunner.TestMethods
+import org.jetbrains.dokka.utilities.DokkaConsoleLogger
+import org.jetbrains.dokka.utilities.DokkaLogger
+
+class TemplatingDokkaTestGenerator(
+    configuration: DokkaConfiguration,
+    logger: DokkaLogger,
+    testMethods: TemplatingTestMethods,
+    additionalPlugins: List<DokkaPlugin> = emptyList()
+) : DokkaTestGenerator<TemplatingTestMethods>(
+    configuration,
+    logger,
+    testMethods,
+    additionalPlugins + TemplatingPlugin() + TestTemplatingPlugin()
+) {
+    override fun generate() = with(testMethods) {
+        val dokkaGenerator = DokkaGenerator(configuration, logger)
+
+        val context =
+            dokkaGenerator.initializePlugins(configuration, logger, additionalPlugins)
+
+        pluginsSetupStage(context)
+
+        val generation = context.single(CoreExtensions.generation) as TestTemplatingGeneration
+
+        generation.processSubmodules()
+        submoduleProcessingStage(context)
+
+        generation.finishProcessing()
+        finishProcessingSubmodules(context)
+    }
+
+}
+
+open class TemplatingTestMethods(
+    open val pluginsSetupStage: (DokkaContext) -> Unit,
+    open val submoduleProcessingStage: (DokkaContext) -> Unit,
+    open val finishProcessingSubmodules: (DokkaContext) -> Unit,
+) : TestMethods
+
+class TemplatingTestBuilder : TestBuilder<TemplatingTestMethods>() {
+    var pluginsSetupStage: (DokkaContext) -> Unit = {}
+    var submoduleProcessingStage: (DokkaContext) -> Unit = {}
+    var finishProcessingSubmodules: (DokkaContext) -> Unit = {}
+
+    override fun build() = TemplatingTestMethods(
+        pluginsSetupStage,
+        submoduleProcessingStage,
+        finishProcessingSubmodules,
+    )
+}
+
+abstract class TemplatingAbstractTest(logger: TestLogger = TestLogger(DokkaConsoleLogger())) :
+    AbstractTest<TemplatingTestMethods, TemplatingTestBuilder, TemplatingDokkaTestGenerator>(
+        ::TemplatingTestBuilder,
+        ::TemplatingDokkaTestGenerator,
+        logger,
+    )
diff --git a/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingGeneration.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingGeneration.kt
new file mode 100644
index 00000000..5dbe2bbe
--- /dev/null
+++ b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingGeneration.kt
@@ -0,0 +1,30 @@
+package org.jetbrains.dokka.templates
+
+import org.jetbrains.dokka.Timer
+import org.jetbrains.dokka.generation.Generation
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.query
+import org.jetbrains.dokka.plugability.querySingle
+
+class TestTemplatingGeneration(private val context: DokkaContext) : Generation {
+
+    val templatingPlugin by lazy { context.plugin<TemplatingPlugin>() }
+
+    override fun Timer.generate() {
+        report("Processing submodules")
+        processSubmodules()
+
+        report("Finishing processing")
+        finishProcessing()
+    }
+
+    fun processSubmodules() =
+        templatingPlugin.querySingle { submoduleTemplateProcessor }.process(context.configuration.modules)
+
+    fun finishProcessing() =
+        templatingPlugin.query { templateProcessingStrategy }.forEach { it.finish(context.configuration.outputDir) }
+
+
+    override val generationName = "test template generation"
+}
\ No newline at end of file
diff --git a/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingPlugin.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingPlugin.kt
new file mode 100644
index 00000000..1ed961b8
--- /dev/null
+++ b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingPlugin.kt
@@ -0,0 +1,16 @@
+package org.jetbrains.dokka.templates
+
+import org.jetbrains.dokka.CoreExtensions
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.plugability.DokkaPlugin
+
+class TestTemplatingPlugin: DokkaPlugin() {
+
+    val dokkaBase by lazy { plugin<DokkaBase>() }
+
+    val allModulesPageGeneration by extending {
+        (CoreExtensions.generation
+                providing ::TestTemplatingGeneration
+                override dokkaBase.singleGeneration)
+    }
+}
\ No newline at end of file
diff --git a/plugins/templating/src/test/kotlin/templates/AddToNavigationCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/templates/AddToNavigationCommandResolutionTest.kt
deleted file mode 100644
index 81d39752..00000000
--- a/plugins/templating/src/test/kotlin/templates/AddToNavigationCommandResolutionTest.kt
+++ /dev/null
@@ -1,137 +0,0 @@
-package org.jetbrains.dokka.templates
-
-import kotlinx.html.a
-import kotlinx.html.div
-import kotlinx.html.id
-import kotlinx.html.span
-import kotlinx.html.stream.createHTML
-import org.jetbrains.dokka.DokkaModuleDescriptionImpl
-import org.jetbrains.dokka.base.renderers.html.templateCommand
-import org.jetbrains.dokka.base.templating.AddToNavigationCommand
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.junit.Rule
-import org.junit.jupiter.api.Test
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.ValueSource
-import org.junit.rules.TemporaryFolder
-import utils.assertHtmlEqualsIgnoringWhitespace
-
-class AddToNavigationCommandResolutionTest : TemplatingAbstractTest() {
-    @get:Rule
-    val folder: TemporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `should substitute AddToNavigationCommand in root directory`() =
-        addToNavigationTest {
-            val output = folder.root.resolve("navigation.html").readText()
-            val expected = expectedOutput(
-                ModuleWithPrefix("module1"),
-                ModuleWithPrefix("module2")
-            )
-            assertHtmlEqualsIgnoringWhitespace(expected, output)
-        }
-
-    @ParameterizedTest
-    @ValueSource(strings = ["module1", "module2"])
-    fun `should substitute AddToNavigationCommand in modules directory`(moduleName: String) =
-        addToNavigationTest {
-            val output = folder.root.resolve(moduleName).resolve("navigation.html").readText()
-            val expected = expectedOutput(
-                ModuleWithPrefix("module1", ".."),
-                ModuleWithPrefix("module2", "..")
-            )
-            assertHtmlEqualsIgnoringWhitespace(expected, output)
-        }
-
-    private fun expectedOutput(vararg modulesWithPrefix: ModuleWithPrefix) = createHTML(prettyPrint = true)
-        .div("sideMenu") {
-            modulesWithPrefix.forEach { (moduleName, prefix) ->
-                val relativePrefix = prefix?.let { "$it/" } ?: ""
-                div("sideMenuPart") {
-                    id = "$moduleName-nav-submenu"
-                    div("overview") {
-                        a {
-                            href = "$relativePrefix$moduleName/module-page.html"
-                            span {
-                                +"module-$moduleName"
-                            }
-                        }
-                    }
-                    div("sideMenuPart") {
-                        id = "$moduleName-nav-submenu-0"
-                        div("overview") {
-                            a {
-                                href = "$relativePrefix$moduleName/$moduleName/package-page.html"
-                                span {
-                                    +"package-$moduleName"
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-    private fun inputForModule(moduleName: String) = createHTML()
-        .templateCommand(AddToNavigationCommand(moduleName)) {
-            div("sideMenuPart") {
-                id = "$moduleName-nav-submenu"
-                div("overview") {
-                    a {
-                        href = "module-page.html"
-                        span {
-                            +"module-$moduleName"
-                        }
-                    }
-                }
-                div("sideMenuPart") {
-                    id = "$moduleName-nav-submenu-0"
-                    div("overview") {
-                        a {
-                            href = "$moduleName/package-page.html"
-                            span {
-                                +"package-$moduleName"
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-    private fun addToNavigationTest(test: (DokkaContext) -> Unit) {
-        folder.create()
-        val module1 = folder.newFolder("module1")
-        val module2 = folder.newFolder("module2")
-
-        val configuration = dokkaConfiguration {
-            modules = listOf(
-                DokkaModuleDescriptionImpl(
-                    name = "module1",
-                    relativePathToOutputDirectory = module1,
-                    includes = emptySet(),
-                    sourceOutputDirectory = module1,
-                ),
-                DokkaModuleDescriptionImpl(
-                    name = "module2",
-                    relativePathToOutputDirectory = module2,
-                    includes = emptySet(),
-                    sourceOutputDirectory = module2,
-                ),
-            )
-            this.outputDir = folder.root
-        }
-
-        val module1Navigation = module1.resolve("navigation.html")
-        module1Navigation.writeText(inputForModule("module1"))
-        val module2Navigation = module2.resolve("navigation.html")
-        module2Navigation.writeText(inputForModule("module2"))
-
-        testFromData(configuration, useOutputLocationFromConfig = true) {
-            finishProcessingSubmodules = { ctx ->
-                test(ctx)
-            }
-        }
-    }
-
-    private data class ModuleWithPrefix(val moduleName: String, val prefix: String? = null)
-}
diff --git a/plugins/templating/src/test/kotlin/templates/AddToSearchCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/templates/AddToSearchCommandResolutionTest.kt
deleted file mode 100644
index d2ad7e0c..00000000
--- a/plugins/templating/src/test/kotlin/templates/AddToSearchCommandResolutionTest.kt
+++ /dev/null
@@ -1,83 +0,0 @@
-package org.jetbrains.dokka.templates
-
-import org.jetbrains.dokka.DokkaModuleDescriptionImpl
-import org.jetbrains.dokka.base.renderers.html.SearchRecord
-import org.jetbrains.dokka.base.templating.AddToSearch
-import org.jetbrains.dokka.base.templating.parseJson
-import org.jetbrains.dokka.base.templating.toJsonString
-import org.junit.Rule
-import org.junit.jupiter.params.ParameterizedTest
-import org.junit.jupiter.params.provider.ValueSource
-import org.junit.rules.TemporaryFolder
-import java.io.File
-import kotlin.test.assertEquals
-
-class AddToSearchCommandResolutionTest : TemplatingAbstractTest() {
-    companion object {
-        val elements = listOf(
-            SearchRecord(name = "name1", location = "location1"),
-            SearchRecord(name = "name2", location = "location2")
-        )
-        val fromModule1 = AddToSearch(
-            moduleName = "module1",
-            elements = elements
-        )
-        val fromModule2 = AddToSearch(
-            moduleName = "module2",
-            elements = elements
-        )
-    }
-
-    @get:Rule
-    val folder: TemporaryFolder = TemporaryFolder()
-
-    @ParameterizedTest
-    @ValueSource(strings = ["pages.json"])
-    fun `should merge navigation templates`(fileName: String) {
-        val (module1Navigation, module2Navigation) = setupTestDirectoriesWithContent(fileName)
-
-        val outputDir = folder.root
-        val configuration = dokkaConfiguration {
-            modules = listOf(
-                DokkaModuleDescriptionImpl(
-                    name = "module1",
-                    relativePathToOutputDirectory = folder.root.resolve("module1"),
-                    includes = emptySet(),
-                    sourceOutputDirectory = folder.root.resolve("module1"),
-                ),
-                DokkaModuleDescriptionImpl(
-                    name = "module2",
-                    relativePathToOutputDirectory = folder.root.resolve("module2"),
-                    includes = emptySet(),
-                    sourceOutputDirectory = folder.root.resolve("module2"),
-                ),
-            )
-            this.outputDir = outputDir
-        }
-
-        testFromData(configuration, useOutputLocationFromConfig = true) {
-            finishProcessingSubmodules = { _ ->
-                val expected = elements.map { it.copy(location = "module1/${it.location}") } +
-                        elements.map { it.copy(location = "module2/${it.location}") }
-
-                val output =
-                    parseJson<List<SearchRecord>>(outputDir.resolve("scripts/${fileName}").readText())
-                assertEquals(expected, output.sortedBy { it.location })
-            }
-        }
-    }
-
-    private fun setupTestDirectoriesWithContent(fileName: String): List<File> {
-        folder.create()
-        val scriptsForModule1 = folder.newFolder("module1", "scripts")
-        val scriptsForModule2 = folder.newFolder("module2", "scripts")
-        folder.newFolder("scripts")
-
-        val module1Navigation = scriptsForModule1.resolve(fileName)
-        module1Navigation.writeText(toJsonString(fromModule1))
-        val module2Navigation = scriptsForModule2.resolve(fileName)
-        module2Navigation.writeText(toJsonString(fromModule2))
-
-        return listOf(module1Navigation, module2Navigation)
-    }
-}
diff --git a/plugins/templating/src/test/kotlin/templates/SubstitutionCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/templates/SubstitutionCommandResolutionTest.kt
deleted file mode 100644
index c31f63c7..00000000
--- a/plugins/templating/src/test/kotlin/templates/SubstitutionCommandResolutionTest.kt
+++ /dev/null
@@ -1,111 +0,0 @@
-package org.jetbrains.dokka.templates
-
-import kotlinx.html.a
-import kotlinx.html.div
-import kotlinx.html.id
-import kotlinx.html.span
-import kotlinx.html.stream.createHTML
-import org.jetbrains.dokka.DokkaModuleDescriptionImpl
-import org.jetbrains.dokka.base.renderers.html.templateCommand
-import org.jetbrains.dokka.base.renderers.html.templateCommandAsHtmlComment
-import org.jetbrains.dokka.base.templating.PathToRootSubstitutionCommand
-import org.junit.Rule
-import org.junit.jupiter.api.Test
-import org.junit.rules.TemporaryFolder
-import utils.assertHtmlEqualsIgnoringWhitespace
-import java.io.File
-
-class SubstitutionCommandResolutionTest : TemplatingAbstractTest() {
-
-    @get:Rule
-    val folder: TemporaryFolder = TemporaryFolder()
-
-    @Test
-    fun `should handle PathToRootCommand`() {
-        val template = createHTML()
-            .templateCommand(PathToRootSubstitutionCommand(pattern = "###", default = "default")) {
-                a {
-                    href = "###index.html"
-                    div {
-                        id = "logo"
-                    }
-                }
-            }
-
-        val expected = createHTML().a {
-            href = "../index.html"
-            div {
-                id = "logo"
-            }
-        }
-        checkSubstitutedResult(template, expected)
-    }
-
-    @Test
-    fun `should handle PathToRootCommand as HTML comment`() {
-        val template = createHTML().span {
-            templateCommandAsHtmlComment(PathToRootSubstitutionCommand(pattern = "###", default = "default")) {
-                this@span.a {
-                    href = "###index.html"
-                    div {
-                        id = "logo"
-                    }
-                }
-                templateCommandAsHtmlComment(PathToRootSubstitutionCommand(pattern = "####", default = "default")) {
-                    this@span.a {
-                        href = "####index.html"
-                        div {
-                            id = "logo"
-                        }
-                    }
-                }
-            }
-        }
-
-        val expected = createHTML().span {
-            a {
-                href = "../index.html"
-                div {
-                    id = "logo"
-                }
-            }
-            a {
-                href = "../index.html"
-                div {
-                    id = "logo"
-                }
-            }
-        }
-        checkSubstitutedResult(template, expected)
-    }
-
-    private fun createDirectoriesAndWriteContent(content: String): File {
-        folder.create()
-        val module1 = folder.newFolder("module1")
-        val module1Content = module1.resolve("index.html")
-        module1Content.writeText(content)
-        return module1Content
-    }
-
-    private fun checkSubstitutedResult(template: String, expected:String) {
-        val testedFile = createDirectoriesAndWriteContent(template)
-
-        val configuration = dokkaConfiguration {
-            modules = listOf(
-                DokkaModuleDescriptionImpl(
-                    name = "module1",
-                    relativePathToOutputDirectory = folder.root.resolve("module1"),
-                    includes = emptySet(),
-                    sourceOutputDirectory = folder.root.resolve("module1"),
-                )
-            )
-            this.outputDir = folder.root
-        }
-
-        testFromData(configuration, useOutputLocationFromConfig = true){
-            finishProcessingSubmodules = {
-                assertHtmlEqualsIgnoringWhitespace(expected, testedFile.readText())
-            }
-        }
-    }
-}
diff --git a/plugins/templating/src/test/kotlin/templates/TemplatingDokkaTestGenerator.kt b/plugins/templating/src/test/kotlin/templates/TemplatingDokkaTestGenerator.kt
deleted file mode 100644
index 50a68efb..00000000
--- a/plugins/templating/src/test/kotlin/templates/TemplatingDokkaTestGenerator.kt
+++ /dev/null
@@ -1,69 +0,0 @@
-package org.jetbrains.dokka.templates
-
-import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.DokkaGenerator
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.testApi.logger.TestLogger
-import org.jetbrains.dokka.testApi.testRunner.AbstractTest
-import org.jetbrains.dokka.testApi.testRunner.DokkaTestGenerator
-import org.jetbrains.dokka.testApi.testRunner.TestBuilder
-import org.jetbrains.dokka.testApi.testRunner.TestMethods
-import org.jetbrains.dokka.utilities.DokkaConsoleLogger
-import org.jetbrains.dokka.utilities.DokkaLogger
-
-class TemplatingDokkaTestGenerator(
-    configuration: DokkaConfiguration,
-    logger: DokkaLogger,
-    testMethods: TemplatingTestMethods,
-    additionalPlugins: List<DokkaPlugin> = emptyList()
-) : DokkaTestGenerator<TemplatingTestMethods>(
-    configuration,
-    logger,
-    testMethods,
-    additionalPlugins + TemplatingPlugin() + TestTemplatingPlugin()
-) {
-    override fun generate() = with(testMethods) {
-        val dokkaGenerator = DokkaGenerator(configuration, logger)
-
-        val context =
-            dokkaGenerator.initializePlugins(configuration, logger, additionalPlugins)
-
-        pluginsSetupStage(context)
-
-        val generation = context.single(CoreExtensions.generation) as TestTemplatingGeneration
-
-        generation.processSubmodules()
-        submoduleProcessingStage(context)
-
-        generation.finishProcessing()
-        finishProcessingSubmodules(context)
-    }
-
-}
-
-open class TemplatingTestMethods(
-    open val pluginsSetupStage: (DokkaContext) -> Unit,
-    open val submoduleProcessingStage: (DokkaContext) -> Unit,
-    open val finishProcessingSubmodules: (DokkaContext) -> Unit,
-) : TestMethods
-
-class TemplatingTestBuilder : TestBuilder<TemplatingTestMethods>() {
-    var pluginsSetupStage: (DokkaContext) -> Unit = {}
-    var submoduleProcessingStage: (DokkaContext) -> Unit = {}
-    var finishProcessingSubmodules: (DokkaContext) -> Unit = {}
-
-    override fun build() = TemplatingTestMethods(
-        pluginsSetupStage,
-        submoduleProcessingStage,
-        finishProcessingSubmodules,
-    )
-}
-
-abstract class TemplatingAbstractTest(logger: TestLogger = TestLogger(DokkaConsoleLogger())) :
-    AbstractTest<TemplatingTestMethods, TemplatingTestBuilder, TemplatingDokkaTestGenerator>(
-        ::TemplatingTestBuilder,
-        ::TemplatingDokkaTestGenerator,
-        logger,
-    )
diff --git a/plugins/templating/src/test/kotlin/templates/TestTemplatingGeneration.kt b/plugins/templating/src/test/kotlin/templates/TestTemplatingGeneration.kt
deleted file mode 100644
index 5dbe2bbe..00000000
--- a/plugins/templating/src/test/kotlin/templates/TestTemplatingGeneration.kt
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.jetbrains.dokka.templates
-
-import org.jetbrains.dokka.Timer
-import org.jetbrains.dokka.generation.Generation
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.query
-import org.jetbrains.dokka.plugability.querySingle
-
-class TestTemplatingGeneration(private val context: DokkaContext) : Generation {
-
-    val templatingPlugin by lazy { context.plugin<TemplatingPlugin>() }
-
-    override fun Timer.generate() {
-        report("Processing submodules")
-        processSubmodules()
-
-        report("Finishing processing")
-        finishProcessing()
-    }
-
-    fun processSubmodules() =
-        templatingPlugin.querySingle { submoduleTemplateProcessor }.process(context.configuration.modules)
-
-    fun finishProcessing() =
-        templatingPlugin.query { templateProcessingStrategy }.forEach { it.finish(context.configuration.outputDir) }
-
-
-    override val generationName = "test template generation"
-}
\ No newline at end of file
diff --git a/plugins/templating/src/test/kotlin/templates/TestTemplatingPlugin.kt b/plugins/templating/src/test/kotlin/templates/TestTemplatingPlugin.kt
deleted file mode 100644
index 1ed961b8..00000000
--- a/plugins/templating/src/test/kotlin/templates/TestTemplatingPlugin.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.jetbrains.dokka.templates
-
-import org.jetbrains.dokka.CoreExtensions
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.plugability.DokkaPlugin
-
-class TestTemplatingPlugin: DokkaPlugin() {
-
-    val dokkaBase by lazy { plugin<DokkaBase>() }
-
-    val allModulesPageGeneration by extending {
-        (CoreExtensions.generation
-                providing ::TestTemplatingGeneration
-                override dokkaBase.singleGeneration)
-    }
-}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/DefaultPreviousDocumentationCopyPostAction.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/DefaultPreviousDocumentationCopyPostAction.kt
new file mode 100644
index 00000000..6ab81d31
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/DefaultPreviousDocumentationCopyPostAction.kt
@@ -0,0 +1,54 @@
+package org.jetbrains.dokka.versioning
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.jetbrains.dokka.renderers.PostAction
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.query
+import org.jetbrains.dokka.plugability.querySingle
+import org.jetbrains.dokka.templates.TemplateProcessingStrategy
+import org.jetbrains.dokka.templates.TemplatingPlugin
+import java.io.File
+
+class DefaultPreviousDocumentationCopyPostAction(private val context: DokkaContext) : PostAction {
+    private val versioningStorage by lazy { context.plugin<VersioningPlugin>().querySingle { versioningStorage } }
+    private val processingStrategies: List<TemplateProcessingStrategy> =
+        context.plugin<TemplatingPlugin>().query { templateProcessingStrategy }
+
+    override fun invoke() {
+        versioningStorage.createVersionFile()
+        versioningStorage.previousVersions.forEach { (_, dirs) -> copyVersion(dirs.src, dirs.dst) }
+    }
+
+    private fun copyVersion(versionRoot: File, targetParent: File) {
+        targetParent.apply { mkdirs() }
+        val ignoreDir = versionRoot.resolve(VersioningConfiguration.OLDER_VERSIONS_DIR)
+        runBlocking(Dispatchers.Default) {
+            coroutineScope {
+                versionRoot.listFiles().orEmpty()
+                    .filter { it.absolutePath != ignoreDir.absolutePath }
+                    .forEach { versionRootContent ->
+                        launch {
+                            processRecursively(versionRootContent, targetParent)
+                        }
+                    }
+            }
+        }
+    }
+
+    private fun processRecursively(versionRootContent: File, targetParent: File) {
+        if (versionRootContent.isDirectory) {
+            val target = targetParent.resolve(versionRootContent.name).also { it.mkdir() }
+            versionRootContent.listFiles()?.forEach {
+                processRecursively(it, target)
+            }
+        } else if (versionRootContent.extension == "html") processingStrategies.first {
+            it.process(versionRootContent, targetParent.resolve(versionRootContent.name), null)
+        } else {
+            versionRootContent.copyTo(targetParent.resolve(versionRootContent.name), overwrite = true)
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionCommandConsumer.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionCommandConsumer.kt
new file mode 100644
index 00000000..ea524c52
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionCommandConsumer.kt
@@ -0,0 +1,50 @@
+package org.jetbrains.dokka.versioning
+
+import kotlinx.html.unsafe
+import kotlinx.html.visit
+import kotlinx.html.visitAndFinalize
+import org.jetbrains.dokka.base.renderers.html.TemplateBlock
+import org.jetbrains.dokka.base.renderers.html.command.consumers.ImmediateResolutionTagConsumer
+import org.jetbrains.dokka.base.renderers.html.templateCommandFor
+import org.jetbrains.dokka.base.templating.Command
+import org.jetbrains.dokka.base.templating.ImmediateHtmlCommandConsumer
+import org.jetbrains.dokka.base.templating.ReplaceVersionsCommand
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.querySingle
+
+class ReplaceVersionCommandConsumer(context: DokkaContext) : ImmediateHtmlCommandConsumer {
+
+    private val versionsNavigationCreator =
+        context.plugin<VersioningPlugin>().querySingle { versionsNavigationCreator }
+    private val versioningStorage =
+        context.plugin<VersioningPlugin>().querySingle { versioningStorage }
+
+    override fun canProcess(command: Command) = command is ReplaceVersionsCommand
+
+    override fun <R> processCommand(
+        command: Command,
+        block: TemplateBlock,
+        tagConsumer: ImmediateResolutionTagConsumer<R>
+    ) {
+        command as ReplaceVersionsCommand
+        templateCommandFor(command, tagConsumer).visit {
+            unsafe {
+                +versionsNavigationCreator(versioningStorage.currentVersion.dir.resolve(command.location))
+            }
+        }
+    }
+
+    override fun <R> processCommandAndFinalize(
+        command: Command,
+        block: TemplateBlock,
+        tagConsumer: ImmediateResolutionTagConsumer<R>
+    ): R {
+        command as ReplaceVersionsCommand
+        return templateCommandFor(command, tagConsumer).visitAndFinalize(tagConsumer) {
+            unsafe {
+                +versionsNavigationCreator(versioningStorage.currentVersion.dir.resolve(command.location))
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionsCommand.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionsCommand.kt
new file mode 100644
index 00000000..66dd9860
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionsCommand.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.dokka.versioning
+
+
+import org.jetbrains.dokka.base.templating.Command
+import org.jetbrains.dokka.base.templating.ReplaceVersionsCommand
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.querySingle
+import org.jetbrains.dokka.templates.CommandHandler
+import org.jsoup.nodes.Element
+import java.io.File
+
+class ReplaceVersionCommandHandler(context: DokkaContext) : CommandHandler {
+
+    val versionsNavigationCreator by lazy {
+        context.plugin<VersioningPlugin>().querySingle { versionsNavigationCreator }
+    }
+
+    override fun canHandle(command: Command): Boolean = command is ReplaceVersionsCommand
+
+    override fun handleCommandAsTag(command: Command, body: Element, input: File, output: File) {
+        body.empty()
+        body.append(versionsNavigationCreator(output))
+    }
+}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningConfiguration.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningConfiguration.kt
new file mode 100644
index 00000000..56c72257
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningConfiguration.kt
@@ -0,0 +1,34 @@
+package org.jetbrains.dokka.versioning
+
+import org.jetbrains.dokka.plugability.ConfigurableBlock
+import org.jetbrains.dokka.plugability.DokkaContext
+import java.io.File
+
+data class VersioningConfiguration(
+    var olderVersionsDir: File? = defaultOlderVersionsDir,
+    var olderVersions: List<File>? = defaultOlderVersions,
+    var versionsOrdering: List<String>? = defaultVersionsOrdering,
+    var version: String? = defaultVersion,
+    var renderVersionsNavigationOnAllPages: Boolean? = defaultRenderVersionsNavigationOnAllPages
+) : ConfigurableBlock {
+    internal fun versionFromConfigurationOrModule(dokkaContext: DokkaContext): String =
+        version ?: dokkaContext.configuration.moduleVersion ?: "1.0"
+
+    internal fun allOlderVersions(): List<File> {
+        if (olderVersionsDir != null)
+            assert(olderVersionsDir!!.isDirectory) { "Supplied previous version $olderVersionsDir is not a directory!" }
+
+        return olderVersionsDir?.listFiles()?.toList().orEmpty() + olderVersions.orEmpty()
+    }
+
+    companion object {
+        val defaultOlderVersionsDir: File? = null
+        val defaultOlderVersions: List<File>? = null
+        val defaultVersionsOrdering: List<String>? = null
+        val defaultVersion = null
+        val defaultRenderVersionsNavigationOnAllPages = true
+
+        const val OLDER_VERSIONS_DIR = "older"
+        const val VERSIONS_FILE = "version.json"
+    }
+}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningPlugin.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningPlugin.kt
new file mode 100644
index 00000000..e4e8bbae
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningPlugin.kt
@@ -0,0 +1,52 @@
+package org.jetbrains.dokka.versioning
+
+import org.jetbrains.dokka.CoreExtensions.postActions
+import org.jetbrains.dokka.base.DokkaBase
+import org.jetbrains.dokka.plugability.DokkaPlugin
+import org.jetbrains.dokka.plugability.configuration
+import org.jetbrains.dokka.templates.TemplatingPlugin
+
+class VersioningPlugin : DokkaPlugin() {
+
+    val versioningStorage by extensionPoint<VersioningStorage>()
+    val versionsNavigationCreator by extensionPoint<VersionsNavigationCreator>()
+    val versionsOrdering by extensionPoint<VersionsOrdering>()
+
+    private val dokkaBase by lazy { plugin<DokkaBase>() }
+    private val templatingPlugin by lazy { plugin<TemplatingPlugin>() }
+
+    val defaultVersioningStorage by extending {
+        versioningStorage providing ::DefaultVersioningStorage
+    }
+    val defaultVersioningNavigationCreator by extending {
+        versionsNavigationCreator providing ::HtmlVersionsNavigationCreator
+    }
+    val replaceVersionCommandHandler by extending {
+        templatingPlugin.directiveBasedCommandHandlers providing ::ReplaceVersionCommandHandler override templatingPlugin.replaceVersionCommandHandler
+    }
+    val resolveLinkConsumer by extending {
+        dokkaBase.immediateHtmlCommandConsumer providing ::ReplaceVersionCommandConsumer override dokkaBase.replaceVersionConsumer
+    }
+    val cssStyleInstaller by extending {
+        dokkaBase.htmlPreprocessors providing ::MultiModuleStylesInstaller order {
+            after(dokkaBase.assetsInstaller)
+            before(dokkaBase.customResourceInstaller)
+        }
+    }
+    val notFoundPageInstaller by extending {
+        dokkaBase.htmlPreprocessors providing ::NotFoundPageInstaller order {
+            after(dokkaBase.assetsInstaller)
+            before(dokkaBase.customResourceInstaller)
+        } applyIf { !delayTemplateSubstitution }
+    }
+    val versionsDefaultOrdering by extending {
+        versionsOrdering providing { ctx ->
+            configuration<VersioningPlugin, VersioningConfiguration>(ctx)?.versionsOrdering?.let {
+                ByConfigurationVersionOrdering(ctx)
+            } ?: SemVerVersionOrdering()
+        }
+    }
+    val previousDocumentationCopyPostAction by extending {
+        postActions providing ::DefaultPreviousDocumentationCopyPostAction applyIf { !delayTemplateSubstitution }
+    }
+}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningStorage.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningStorage.kt
new file mode 100644
index 00000000..6e1dd7ca
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningStorage.kt
@@ -0,0 +1,65 @@
+package org.jetbrains.dokka.versioning
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.configuration
+import java.io.File
+
+data class VersionDirs(val src: File, val dst: File)
+data class CurrentVersion(val name: String, val dir: File)
+
+interface VersioningStorage {
+    val previousVersions: Map<VersionId, VersionDirs>
+    val currentVersion: CurrentVersion
+    fun createVersionFile()
+}
+
+typealias VersionId = String
+
+class DefaultVersioningStorage(val context: DokkaContext) : VersioningStorage {
+
+    private val mapper = ObjectMapper()
+    private val configuration = configuration<VersioningPlugin, VersioningConfiguration>(context)
+
+    override val previousVersions: Map<VersionId, VersionDirs> by lazy {
+        configuration?.let { versionsConfiguration ->
+            getPreviousVersions(versionsConfiguration.allOlderVersions(), context.configuration.outputDir)
+        } ?: emptyMap()
+    }
+
+    override val currentVersion: CurrentVersion by lazy {
+        configuration?.let { versionsConfiguration ->
+            CurrentVersion(versionsConfiguration.versionFromConfigurationOrModule(context),
+                context.configuration.outputDir)
+        }?: CurrentVersion(context.configuration.moduleVersion.orEmpty(), context.configuration.outputDir)
+    }
+
+    override fun createVersionFile() {
+        mapper.writeValue(
+            currentVersion.dir.resolve(VersioningConfiguration.VERSIONS_FILE),
+            Version(currentVersion.name)
+        )
+    }
+
+    private fun getPreviousVersions(olderVersions: List<File>, output: File): Map<String, VersionDirs> =
+        versionsFrom(olderVersions).associate { (key, srcDir) ->
+            key to VersionDirs(srcDir, output.resolve(VersioningConfiguration.OLDER_VERSIONS_DIR).resolve(key))
+        }
+
+    private fun versionsFrom(olderVersions: List<File>) =
+        olderVersions.mapNotNull { versionDir ->
+            versionDir.listFiles { _, name -> name == VersioningConfiguration.VERSIONS_FILE }?.firstOrNull()
+                ?.let { file ->
+                    val versionsContent = mapper.readValue<Version>(file)
+                    Pair(versionsContent.version, versionDir)
+                }.also {
+                    if (it == null) context.logger.warn("Failed to find versions file named ${VersioningConfiguration.VERSIONS_FILE} in $versionDir")
+                }
+        }
+
+    private data class Version(
+        @JsonProperty("version") val version: String,
+    )
+}
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsNavigationCreator.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsNavigationCreator.kt
new file mode 100644
index 00000000..719d2cf9
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsNavigationCreator.kt
@@ -0,0 +1,86 @@
+package org.jetbrains.dokka.versioning
+
+import kotlinx.html.a
+import kotlinx.html.div
+import kotlinx.html.stream.appendHTML
+import org.jetbrains.dokka.base.renderers.html.strike
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.configuration
+import org.jetbrains.dokka.plugability.plugin
+import org.jetbrains.dokka.plugability.querySingle
+import org.jetbrains.dokka.utilities.urlEncoded
+import java.io.File
+
+fun interface VersionsNavigationCreator {
+    operator fun invoke(output: File): String
+}
+
+class HtmlVersionsNavigationCreator(private val context: DokkaContext) : VersionsNavigationCreator {
+
+    private val versioningStorage by lazy { context.plugin<VersioningPlugin>().querySingle { versioningStorage } }
+
+    private val versionsOrdering by lazy { context.plugin<VersioningPlugin>().querySingle { versionsOrdering } }
+
+    private val isOnlyOnRootPage =
+        configuration<VersioningPlugin, VersioningConfiguration>(context)?.renderVersionsNavigationOnAllPages == false
+
+    private val versions: Map<VersionId, File> by lazy {
+        versioningStorage.previousVersions.map { (k, v) -> k to v.dst }.toMap() +
+                (versioningStorage.currentVersion.name to versioningStorage.currentVersion.dir)
+    }
+
+    override fun invoke(output: File): String {
+        if (versions.size == 1) {
+            return versioningStorage.currentVersion.name
+        }
+        val position = output.takeIf { it.isDirectory } ?: output.parentFile
+        if (isOnlyOnRootPage) {
+            getActiveVersion(position)?.takeIf {
+                it.value == versioningStorage.currentVersion.dir
+                        && it.value != position
+            }?.also { return@invoke it.key }
+        }
+        return versions
+            .let { versions -> versionsOrdering.order(versions.keys.toList()).map { it to versions[it] } }
+            .takeIf { it.isNotEmpty() }
+            ?.let { orderedVersions ->
+                StringBuilder().appendHTML().div(classes = "versions-dropdown") {
+                    val activeVersion = getActiveVersion(position)
+                    val relativePosition: String  = activeVersion?.value?.let { output.toRelativeString(it) } ?: "index.html"
+                    div(classes = "versions-dropdown-button") {
+                        activeVersion?.key?.let { text(it) }
+                    }
+                    div(classes = "versions-dropdown-data") {
+                        orderedVersions.forEach { (version, path) ->
+                            if (version == activeVersion?.key) {
+                                a(href = output.name) { text(version) }
+                            } else {
+                                val isExistsFile =
+                                    if (version == versioningStorage.currentVersion.name)
+                                        path?.resolve(relativePosition)?.exists() == true
+                                    else
+                                        versioningStorage.previousVersions[version]?.src?.resolve(relativePosition)
+                                            ?.exists() == true
+
+                                val absolutePath =
+                                    if (isExistsFile)
+                                        path?.resolve(relativePosition)
+                                    else
+                                        versioningStorage.currentVersion.dir.resolve("not-found-version.html")
+
+                                a(href = absolutePath?.toRelativeString(position) +
+                                        if (!isExistsFile) "?v=" + version.urlEncoded() else "") {
+                                        text(version)
+                                }
+                            }
+                        }
+                    }
+                }.toString()
+            }.orEmpty()
+    }
+
+    private fun getActiveVersion(position: File) =
+        versions.minByOrNull { (_, versionLocation) ->
+            versionLocation.let { position.toRelativeString(it).length }
+        }
+}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsOrdering.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsOrdering.kt
new file mode 100644
index 00000000..f72e2df6
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsOrdering.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.dokka.versioning
+
+import org.apache.maven.artifact.versioning.ComparableVersion
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.plugability.configuration
+import org.jetbrains.dokka.versioning.VersionId
+import org.jetbrains.dokka.versioning.VersioningConfiguration
+import org.jetbrains.dokka.versioning.VersioningPlugin
+
+fun interface VersionsOrdering {
+    fun order(records: List<VersionId>): List<VersionId>
+}
+
+class ByConfigurationVersionOrdering(val dokkaContext: DokkaContext) : VersionsOrdering {
+    override fun order(records: List<VersionId>): List<VersionId> =
+        configuration<VersioningPlugin, VersioningConfiguration>(dokkaContext)?.versionsOrdering
+            ?: throw IllegalStateException("Attempted to use a configuration ordering without providing configuration")
+}
+
+class SemVerVersionOrdering : VersionsOrdering {
+    override fun order(records: List<VersionId>): List<VersionId> =
+        records.map { it to ComparableVersion(it) }.sortedByDescending { it.second }.map { it.first }
+}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/htmlPreprocessors.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/htmlPreprocessors.kt
new file mode 100644
index 00000000..94400898
--- /dev/null
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/htmlPreprocessors.kt
@@ -0,0 +1,38 @@
+package org.jetbrains.dokka.versioning
+
+import org.jetbrains.dokka.pages.RendererSpecificResourcePage
+import org.jetbrains.dokka.pages.RenderingStrategy
+import org.jetbrains.dokka.pages.RootPageNode
+import org.jetbrains.dokka.plugability.DokkaContext
+import org.jetbrains.dokka.transformers.pages.PageTransformer
+
+class MultiModuleStylesInstaller(private val dokkaContext: DokkaContext) : PageTransformer {
+    private val stylesPages = listOf(
+        "styles/multimodule.css",
+    )
+
+    override fun invoke(input: RootPageNode): RootPageNode =
+        input.let { root ->
+            if (dokkaContext.configuration.delayTemplateSubstitution) root
+            else root.modified(children = input.children + stylesPages.toRenderSpecificResourcePage())
+        }.transformContentPagesTree {
+            it.modified(
+                embeddedResources = it.embeddedResources + stylesPages
+            )
+        }
+}
+
+class NotFoundPageInstaller(private val dokkaContext: DokkaContext) : PageTransformer {
+    private val notFoundPage = listOf(
+        "not-found-version.html",
+    )
+
+    override fun invoke(input: RootPageNode): RootPageNode =
+        input.let { root ->
+            if (dokkaContext.configuration.delayTemplateSubstitution) root
+            else root.modified(children = input.children + notFoundPage.toRenderSpecificResourcePage())
+        }
+}
+
+private fun List<String>.toRenderSpecificResourcePage(): List<RendererSpecificResourcePage> =
+    map { RendererSpecificResourcePage(it, emptyList(), RenderingStrategy.Copy("/dokka/$it")) }
diff --git a/plugins/versioning/src/main/kotlin/versioning/DefaultPreviousDocumentationCopyPostAction.kt b/plugins/versioning/src/main/kotlin/versioning/DefaultPreviousDocumentationCopyPostAction.kt
deleted file mode 100644
index 6ab81d31..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/DefaultPreviousDocumentationCopyPostAction.kt
+++ /dev/null
@@ -1,54 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-import org.jetbrains.dokka.renderers.PostAction
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.query
-import org.jetbrains.dokka.plugability.querySingle
-import org.jetbrains.dokka.templates.TemplateProcessingStrategy
-import org.jetbrains.dokka.templates.TemplatingPlugin
-import java.io.File
-
-class DefaultPreviousDocumentationCopyPostAction(private val context: DokkaContext) : PostAction {
-    private val versioningStorage by lazy { context.plugin<VersioningPlugin>().querySingle { versioningStorage } }
-    private val processingStrategies: List<TemplateProcessingStrategy> =
-        context.plugin<TemplatingPlugin>().query { templateProcessingStrategy }
-
-    override fun invoke() {
-        versioningStorage.createVersionFile()
-        versioningStorage.previousVersions.forEach { (_, dirs) -> copyVersion(dirs.src, dirs.dst) }
-    }
-
-    private fun copyVersion(versionRoot: File, targetParent: File) {
-        targetParent.apply { mkdirs() }
-        val ignoreDir = versionRoot.resolve(VersioningConfiguration.OLDER_VERSIONS_DIR)
-        runBlocking(Dispatchers.Default) {
-            coroutineScope {
-                versionRoot.listFiles().orEmpty()
-                    .filter { it.absolutePath != ignoreDir.absolutePath }
-                    .forEach { versionRootContent ->
-                        launch {
-                            processRecursively(versionRootContent, targetParent)
-                        }
-                    }
-            }
-        }
-    }
-
-    private fun processRecursively(versionRootContent: File, targetParent: File) {
-        if (versionRootContent.isDirectory) {
-            val target = targetParent.resolve(versionRootContent.name).also { it.mkdir() }
-            versionRootContent.listFiles()?.forEach {
-                processRecursively(it, target)
-            }
-        } else if (versionRootContent.extension == "html") processingStrategies.first {
-            it.process(versionRootContent, targetParent.resolve(versionRootContent.name), null)
-        } else {
-            versionRootContent.copyTo(targetParent.resolve(versionRootContent.name), overwrite = true)
-        }
-    }
-}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionCommandConsumer.kt b/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionCommandConsumer.kt
deleted file mode 100644
index ea524c52..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionCommandConsumer.kt
+++ /dev/null
@@ -1,50 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-import kotlinx.html.unsafe
-import kotlinx.html.visit
-import kotlinx.html.visitAndFinalize
-import org.jetbrains.dokka.base.renderers.html.TemplateBlock
-import org.jetbrains.dokka.base.renderers.html.command.consumers.ImmediateResolutionTagConsumer
-import org.jetbrains.dokka.base.renderers.html.templateCommandFor
-import org.jetbrains.dokka.base.templating.Command
-import org.jetbrains.dokka.base.templating.ImmediateHtmlCommandConsumer
-import org.jetbrains.dokka.base.templating.ReplaceVersionsCommand
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.querySingle
-
-class ReplaceVersionCommandConsumer(context: DokkaContext) : ImmediateHtmlCommandConsumer {
-
-    private val versionsNavigationCreator =
-        context.plugin<VersioningPlugin>().querySingle { versionsNavigationCreator }
-    private val versioningStorage =
-        context.plugin<VersioningPlugin>().querySingle { versioningStorage }
-
-    override fun canProcess(command: Command) = command is ReplaceVersionsCommand
-
-    override fun <R> processCommand(
-        command: Command,
-        block: TemplateBlock,
-        tagConsumer: ImmediateResolutionTagConsumer<R>
-    ) {
-        command as ReplaceVersionsCommand
-        templateCommandFor(command, tagConsumer).visit {
-            unsafe {
-                +versionsNavigationCreator(versioningStorage.currentVersion.dir.resolve(command.location))
-            }
-        }
-    }
-
-    override fun <R> processCommandAndFinalize(
-        command: Command,
-        block: TemplateBlock,
-        tagConsumer: ImmediateResolutionTagConsumer<R>
-    ): R {
-        command as ReplaceVersionsCommand
-        return templateCommandFor(command, tagConsumer).visitAndFinalize(tagConsumer) {
-            unsafe {
-                +versionsNavigationCreator(versioningStorage.currentVersion.dir.resolve(command.location))
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionsCommand.kt b/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionsCommand.kt
deleted file mode 100644
index ad1edd2b..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionsCommand.kt
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-
-import org.jetbrains.dokka.base.templating.Command
-import org.jetbrains.dokka.base.templating.ReplaceVersionsCommand
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.querySingle
-import org.jetbrains.dokka.templates.CommandHandler
-import org.jsoup.nodes.Element
-import java.io.File
-
-class ReplaceVersionCommandHandler(context: DokkaContext) : CommandHandler {
-
-    val versionsNavigationCreator by lazy {
-        context.plugin<VersioningPlugin>().querySingle { versionsNavigationCreator }
-    }
-
-    override fun canHandle(command: Command): Boolean = command is ReplaceVersionsCommand
-
-    override fun handleCommandAsTag(command: Command, element: Element, input: File, output: File) {
-        element.empty()
-        element.append(versionsNavigationCreator(output))
-    }
-}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersioningConfiguration.kt b/plugins/versioning/src/main/kotlin/versioning/VersioningConfiguration.kt
deleted file mode 100644
index 56c72257..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/VersioningConfiguration.kt
+++ /dev/null
@@ -1,34 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-import org.jetbrains.dokka.plugability.ConfigurableBlock
-import org.jetbrains.dokka.plugability.DokkaContext
-import java.io.File
-
-data class VersioningConfiguration(
-    var olderVersionsDir: File? = defaultOlderVersionsDir,
-    var olderVersions: List<File>? = defaultOlderVersions,
-    var versionsOrdering: List<String>? = defaultVersionsOrdering,
-    var version: String? = defaultVersion,
-    var renderVersionsNavigationOnAllPages: Boolean? = defaultRenderVersionsNavigationOnAllPages
-) : ConfigurableBlock {
-    internal fun versionFromConfigurationOrModule(dokkaContext: DokkaContext): String =
-        version ?: dokkaContext.configuration.moduleVersion ?: "1.0"
-
-    internal fun allOlderVersions(): List<File> {
-        if (olderVersionsDir != null)
-            assert(olderVersionsDir!!.isDirectory) { "Supplied previous version $olderVersionsDir is not a directory!" }
-
-        return olderVersionsDir?.listFiles()?.toList().orEmpty() + olderVersions.orEmpty()
-    }
-
-    companion object {
-        val defaultOlderVersionsDir: File? = null
-        val defaultOlderVersions: List<File>? = null
-        val defaultVersionsOrdering: List<String>? = null
-        val defaultVersion = null
-        val defaultRenderVersionsNavigationOnAllPages = true
-
-        const val OLDER_VERSIONS_DIR = "older"
-        const val VERSIONS_FILE = "version.json"
-    }
-}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersioningPlugin.kt b/plugins/versioning/src/main/kotlin/versioning/VersioningPlugin.kt
deleted file mode 100644
index e4e8bbae..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/VersioningPlugin.kt
+++ /dev/null
@@ -1,52 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-import org.jetbrains.dokka.CoreExtensions.postActions
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.plugability.DokkaPlugin
-import org.jetbrains.dokka.plugability.configuration
-import org.jetbrains.dokka.templates.TemplatingPlugin
-
-class VersioningPlugin : DokkaPlugin() {
-
-    val versioningStorage by extensionPoint<VersioningStorage>()
-    val versionsNavigationCreator by extensionPoint<VersionsNavigationCreator>()
-    val versionsOrdering by extensionPoint<VersionsOrdering>()
-
-    private val dokkaBase by lazy { plugin<DokkaBase>() }
-    private val templatingPlugin by lazy { plugin<TemplatingPlugin>() }
-
-    val defaultVersioningStorage by extending {
-        versioningStorage providing ::DefaultVersioningStorage
-    }
-    val defaultVersioningNavigationCreator by extending {
-        versionsNavigationCreator providing ::HtmlVersionsNavigationCreator
-    }
-    val replaceVersionCommandHandler by extending {
-        templatingPlugin.directiveBasedCommandHandlers providing ::ReplaceVersionCommandHandler override templatingPlugin.replaceVersionCommandHandler
-    }
-    val resolveLinkConsumer by extending {
-        dokkaBase.immediateHtmlCommandConsumer providing ::ReplaceVersionCommandConsumer override dokkaBase.replaceVersionConsumer
-    }
-    val cssStyleInstaller by extending {
-        dokkaBase.htmlPreprocessors providing ::MultiModuleStylesInstaller order {
-            after(dokkaBase.assetsInstaller)
-            before(dokkaBase.customResourceInstaller)
-        }
-    }
-    val notFoundPageInstaller by extending {
-        dokkaBase.htmlPreprocessors providing ::NotFoundPageInstaller order {
-            after(dokkaBase.assetsInstaller)
-            before(dokkaBase.customResourceInstaller)
-        } applyIf { !delayTemplateSubstitution }
-    }
-    val versionsDefaultOrdering by extending {
-        versionsOrdering providing { ctx ->
-            configuration<VersioningPlugin, VersioningConfiguration>(ctx)?.versionsOrdering?.let {
-                ByConfigurationVersionOrdering(ctx)
-            } ?: SemVerVersionOrdering()
-        }
-    }
-    val previousDocumentationCopyPostAction by extending {
-        postActions providing ::DefaultPreviousDocumentationCopyPostAction applyIf { !delayTemplateSubstitution }
-    }
-}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersioningStorage.kt b/plugins/versioning/src/main/kotlin/versioning/VersioningStorage.kt
deleted file mode 100644
index 6e1dd7ca..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/VersioningStorage.kt
+++ /dev/null
@@ -1,65 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-import com.fasterxml.jackson.annotation.JsonProperty
-import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.module.kotlin.readValue
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.configuration
-import java.io.File
-
-data class VersionDirs(val src: File, val dst: File)
-data class CurrentVersion(val name: String, val dir: File)
-
-interface VersioningStorage {
-    val previousVersions: Map<VersionId, VersionDirs>
-    val currentVersion: CurrentVersion
-    fun createVersionFile()
-}
-
-typealias VersionId = String
-
-class DefaultVersioningStorage(val context: DokkaContext) : VersioningStorage {
-
-    private val mapper = ObjectMapper()
-    private val configuration = configuration<VersioningPlugin, VersioningConfiguration>(context)
-
-    override val previousVersions: Map<VersionId, VersionDirs> by lazy {
-        configuration?.let { versionsConfiguration ->
-            getPreviousVersions(versionsConfiguration.allOlderVersions(), context.configuration.outputDir)
-        } ?: emptyMap()
-    }
-
-    override val currentVersion: CurrentVersion by lazy {
-        configuration?.let { versionsConfiguration ->
-            CurrentVersion(versionsConfiguration.versionFromConfigurationOrModule(context),
-                context.configuration.outputDir)
-        }?: CurrentVersion(context.configuration.moduleVersion.orEmpty(), context.configuration.outputDir)
-    }
-
-    override fun createVersionFile() {
-        mapper.writeValue(
-            currentVersion.dir.resolve(VersioningConfiguration.VERSIONS_FILE),
-            Version(currentVersion.name)
-        )
-    }
-
-    private fun getPreviousVersions(olderVersions: List<File>, output: File): Map<String, VersionDirs> =
-        versionsFrom(olderVersions).associate { (key, srcDir) ->
-            key to VersionDirs(srcDir, output.resolve(VersioningConfiguration.OLDER_VERSIONS_DIR).resolve(key))
-        }
-
-    private fun versionsFrom(olderVersions: List<File>) =
-        olderVersions.mapNotNull { versionDir ->
-            versionDir.listFiles { _, name -> name == VersioningConfiguration.VERSIONS_FILE }?.firstOrNull()
-                ?.let { file ->
-                    val versionsContent = mapper.readValue<Version>(file)
-                    Pair(versionsContent.version, versionDir)
-                }.also {
-                    if (it == null) context.logger.warn("Failed to find versions file named ${VersioningConfiguration.VERSIONS_FILE} in $versionDir")
-                }
-        }
-
-    private data class Version(
-        @JsonProperty("version") val version: String,
-    )
-}
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersionsNavigationCreator.kt b/plugins/versioning/src/main/kotlin/versioning/VersionsNavigationCreator.kt
deleted file mode 100644
index 719d2cf9..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/VersionsNavigationCreator.kt
+++ /dev/null
@@ -1,86 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-import kotlinx.html.a
-import kotlinx.html.div
-import kotlinx.html.stream.appendHTML
-import org.jetbrains.dokka.base.renderers.html.strike
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.configuration
-import org.jetbrains.dokka.plugability.plugin
-import org.jetbrains.dokka.plugability.querySingle
-import org.jetbrains.dokka.utilities.urlEncoded
-import java.io.File
-
-fun interface VersionsNavigationCreator {
-    operator fun invoke(output: File): String
-}
-
-class HtmlVersionsNavigationCreator(private val context: DokkaContext) : VersionsNavigationCreator {
-
-    private val versioningStorage by lazy { context.plugin<VersioningPlugin>().querySingle { versioningStorage } }
-
-    private val versionsOrdering by lazy { context.plugin<VersioningPlugin>().querySingle { versionsOrdering } }
-
-    private val isOnlyOnRootPage =
-        configuration<VersioningPlugin, VersioningConfiguration>(context)?.renderVersionsNavigationOnAllPages == false
-
-    private val versions: Map<VersionId, File> by lazy {
-        versioningStorage.previousVersions.map { (k, v) -> k to v.dst }.toMap() +
-                (versioningStorage.currentVersion.name to versioningStorage.currentVersion.dir)
-    }
-
-    override fun invoke(output: File): String {
-        if (versions.size == 1) {
-            return versioningStorage.currentVersion.name
-        }
-        val position = output.takeIf { it.isDirectory } ?: output.parentFile
-        if (isOnlyOnRootPage) {
-            getActiveVersion(position)?.takeIf {
-                it.value == versioningStorage.currentVersion.dir
-                        && it.value != position
-            }?.also { return@invoke it.key }
-        }
-        return versions
-            .let { versions -> versionsOrdering.order(versions.keys.toList()).map { it to versions[it] } }
-            .takeIf { it.isNotEmpty() }
-            ?.let { orderedVersions ->
-                StringBuilder().appendHTML().div(classes = "versions-dropdown") {
-                    val activeVersion = getActiveVersion(position)
-                    val relativePosition: String  = activeVersion?.value?.let { output.toRelativeString(it) } ?: "index.html"
-                    div(classes = "versions-dropdown-button") {
-                        activeVersion?.key?.let { text(it) }
-                    }
-                    div(classes = "versions-dropdown-data") {
-                        orderedVersions.forEach { (version, path) ->
-                            if (version == activeVersion?.key) {
-                                a(href = output.name) { text(version) }
-                            } else {
-                                val isExistsFile =
-                                    if (version == versioningStorage.currentVersion.name)
-                                        path?.resolve(relativePosition)?.exists() == true
-                                    else
-                                        versioningStorage.previousVersions[version]?.src?.resolve(relativePosition)
-                                            ?.exists() == true
-
-                                val absolutePath =
-                                    if (isExistsFile)
-                                        path?.resolve(relativePosition)
-                                    else
-                                        versioningStorage.currentVersion.dir.resolve("not-found-version.html")
-
-                                a(href = absolutePath?.toRelativeString(position) +
-                                        if (!isExistsFile) "?v=" + version.urlEncoded() else "") {
-                                        text(version)
-                                }
-                            }
-                        }
-                    }
-                }.toString()
-            }.orEmpty()
-    }
-
-    private fun getActiveVersion(position: File) =
-        versions.minByOrNull { (_, versionLocation) ->
-            versionLocation.let { position.toRelativeString(it).length }
-        }
-}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersionsOrdering.kt b/plugins/versioning/src/main/kotlin/versioning/VersionsOrdering.kt
deleted file mode 100644
index f72e2df6..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/VersionsOrdering.kt
+++ /dev/null
@@ -1,23 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-import org.apache.maven.artifact.versioning.ComparableVersion
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.plugability.configuration
-import org.jetbrains.dokka.versioning.VersionId
-import org.jetbrains.dokka.versioning.VersioningConfiguration
-import org.jetbrains.dokka.versioning.VersioningPlugin
-
-fun interface VersionsOrdering {
-    fun order(records: List<VersionId>): List<VersionId>
-}
-
-class ByConfigurationVersionOrdering(val dokkaContext: DokkaContext) : VersionsOrdering {
-    override fun order(records: List<VersionId>): List<VersionId> =
-        configuration<VersioningPlugin, VersioningConfiguration>(dokkaContext)?.versionsOrdering
-            ?: throw IllegalStateException("Attempted to use a configuration ordering without providing configuration")
-}
-
-class SemVerVersionOrdering : VersionsOrdering {
-    override fun order(records: List<VersionId>): List<VersionId> =
-        records.map { it to ComparableVersion(it) }.sortedByDescending { it.second }.map { it.first }
-}
\ No newline at end of file
diff --git a/plugins/versioning/src/main/kotlin/versioning/htmlPreprocessors.kt b/plugins/versioning/src/main/kotlin/versioning/htmlPreprocessors.kt
deleted file mode 100644
index 94400898..00000000
--- a/plugins/versioning/src/main/kotlin/versioning/htmlPreprocessors.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-package org.jetbrains.dokka.versioning
-
-import org.jetbrains.dokka.pages.RendererSpecificResourcePage
-import org.jetbrains.dokka.pages.RenderingStrategy
-import org.jetbrains.dokka.pages.RootPageNode
-import org.jetbrains.dokka.plugability.DokkaContext
-import org.jetbrains.dokka.transformers.pages.PageTransformer
-
-class MultiModuleStylesInstaller(private val dokkaContext: DokkaContext) : PageTransformer {
-    private val stylesPages = listOf(
-        "styles/multimodule.css",
-    )
-
-    override fun invoke(input: RootPageNode): RootPageNode =
-        input.let { root ->
-            if (dokkaContext.configuration.delayTemplateSubstitution) root
-            else root.modified(children = input.children + stylesPages.toRenderSpecificResourcePage())
-        }.transformContentPagesTree {
-            it.modified(
-                embeddedResources = it.embeddedResources + stylesPages
-            )
-        }
-}
-
-class NotFoundPageInstaller(private val dokkaContext: DokkaContext) : PageTransformer {
-    private val notFoundPage = listOf(
-        "not-found-version.html",
-    )
-
-    override fun invoke(input: RootPageNode): RootPageNode =
-        input.let { root ->
-            if (dokkaContext.configuration.delayTemplateSubstitution) root
-            else root.modified(children = input.children + notFoundPage.toRenderSpecificResourcePage())
-        }
-}
-
-private fun List<String>.toRenderSpecificResourcePage(): List<RendererSpecificResourcePage> =
-    map { RendererSpecificResourcePage(it, emptyList(), RenderingStrategy.Copy("/dokka/$it")) }
-- 
cgit