diff --git a/build.gradle.kts b/build.gradle.kts
index 0e45f9853c..d9ee594337 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -4,7 +4,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 plugins {
     kotlin("jvm") apply false
     id("java")
-    id("org.jetbrains.dokka") version "1.5.0"
+    id("org.jetbrains.dokka") version "1.6.20"
     id("io.github.gradle-nexus.publish-plugin")
 }
 
@@ -21,10 +21,13 @@ allprojects {
     tasks.withType(KotlinCompile::class).all {
         kotlinOptions {
             freeCompilerArgs = freeCompilerArgs + listOf(
-                "-Xopt-in=kotlin.RequiresOptIn",
+                "-opt-in=kotlin.RequiresOptIn",
+                "-Xjsr305=strict",
                 "-Xskip-metadata-version-check",
-                "-Xjsr305=strict"
+                // need 1.4 support, otherwise there might be problems with Gradle 6.x (it's bundling Kotlin 1.4)
+                "-Xsuppress-version-warnings"
             )
+            allWarningsAsErrors = true
             languageVersion = language_version
             apiVersion = language_version
             jvmTarget = "1.8"
diff --git a/core/src/main/kotlin/configuration.kt b/core/src/main/kotlin/configuration.kt
index c7feb22e31..c26faf2877 100644
--- a/core/src/main/kotlin/configuration.kt
+++ b/core/src/main/kotlin/configuration.kt
@@ -235,7 +235,7 @@ interface DokkaConfiguration : Serializable {
 
     interface PackageOptions : Serializable {
         val matchingRegex: String
-        @Deprecated(message = "Use [documentedVisibilities] property for a more flexible control over documented visibilities")
+        @Deprecated("Use [documentedVisibilities] property for a more flexible control over documented visibilities")
         val includeNonPublic: Boolean
         val reportUndocumented: Boolean?
         val skipDeprecated: Boolean
diff --git a/core/src/main/kotlin/defaultConfiguration.kt b/core/src/main/kotlin/defaultConfiguration.kt
index 3ab1782c79..8c7c8b5da4 100644
--- a/core/src/main/kotlin/defaultConfiguration.kt
+++ b/core/src/main/kotlin/defaultConfiguration.kt
@@ -37,6 +37,7 @@ data class DokkaSourceSetImpl(
     override val dependentSourceSets: Set<DokkaSourceSetID> = emptySet(),
     override val samples: Set<File> = emptySet(),
     override val includes: Set<File> = emptySet(),
+    @Deprecated("Use [documentedVisibilities] property for a more flexible control over documented visibilities")
     override val includeNonPublic: Boolean = DokkaDefaults.includeNonPublic,
     override val reportUndocumented: Boolean = DokkaDefaults.reportUndocumented,
     override val skipEmptyPackages: Boolean = DokkaDefaults.skipEmptyPackages,
@@ -79,6 +80,7 @@ data class SourceLinkDefinitionImpl(
 
 data class PackageOptionsImpl(
     override val matchingRegex: String,
+    @Deprecated("Use [documentedVisibilities] property for a more flexible control over documented visibilities")
     override val includeNonPublic: Boolean,
     override val reportUndocumented: Boolean?,
     override val skipDeprecated: Boolean,
diff --git a/core/src/main/kotlin/pages/PageNodes.kt b/core/src/main/kotlin/pages/PageNodes.kt
index 75e27dccab..c643fd4be1 100644
--- a/core/src/main/kotlin/pages/PageNodes.kt
+++ b/core/src/main/kotlin/pages/PageNodes.kt
@@ -21,7 +21,7 @@ interface ContentPage : PageNode {
     val embeddedResources: List<String>
 
     @Deprecated("Deprecated. Remove its usages from your code.",
-        ReplaceWith("documentables.firstOrNull()")
+        ReplaceWith("this.documentables.firstOrNull()")
     )
     val documentable: Documentable?
         get() = if (this is WithDocumentables) this.documentables.firstOrNull() else null
diff --git a/core/test-api/src/main/kotlin/testApi/testRunner/TestDokkaConfigurationBuilder.kt b/core/test-api/src/main/kotlin/testApi/testRunner/TestDokkaConfigurationBuilder.kt
index 623fcc2de5..50ab3bad9d 100644
--- a/core/test-api/src/main/kotlin/testApi/testRunner/TestDokkaConfigurationBuilder.kt
+++ b/core/test-api/src/main/kotlin/testApi/testRunner/TestDokkaConfigurationBuilder.kt
@@ -106,6 +106,7 @@ class DokkaSourceSetBuilder(
     var externalDocumentationLinks: List<ExternalDocumentationLinkImpl> = emptyList(),
     var sourceLinks: List<SourceLinkDefinitionImpl> = emptyList()
 ) {
+    @Suppress("DEPRECATION")
     fun build() = DokkaSourceSetImpl(
         displayName = displayName,
         sourceSetID = DokkaSourceSetID(moduleName, name),
diff --git a/integration-tests/gradle/projects/it-basic-groovy/build.gradle b/integration-tests/gradle/projects/it-basic-groovy/build.gradle
index dc469bba91..f368ed108e 100644
--- a/integration-tests/gradle/projects/it-basic-groovy/build.gradle
+++ b/integration-tests/gradle/projects/it-basic-groovy/build.gradle
@@ -19,6 +19,23 @@ dokkaHtml {
             displayName.set("custom")
             reportUndocumented.set(true)
         }
+
+        configureEach {
+            perPackageOption { // testing closures
+                matchingRegex.set(".*internal.*")
+                suppress.set(true)
+            }
+
+            sourceLink { // testing closures
+                localDirectory.set(file("src/main"))
+                remoteUrl.set(
+                        new URL(
+                                "https://github.com/Kotlin/dokka/tree/master/" +
+                                        "integration-tests/gradle/projects/it-basic-groovy/src/main"
+                        )
+                )
+            }
+        }
     }
 
 }
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt
index 452b821c9b..4691670578 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/AnalysisEnvironment.kt
@@ -114,8 +114,11 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
             JavadocTagInfo.EP_NAME, JavadocTagInfo::class.java
         )
 
+        @Suppress("DEPRECATION")
+        val extensionArea = Extensions.getRootArea()
+
         CoreApplicationEnvironment.registerExtensionPoint(
-            Extensions.getRootArea(),
+            extensionArea,
             CustomJavadocTagProvider.EP_NAME, CustomJavadocTagProvider::class.java
         )
 
@@ -588,8 +591,12 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
             instances: List<T>,
             disposable: Disposable
         ) {
-            if (Extensions.getRootArea().hasExtensionPoint(appExtension.extensionPointName))
+            @Suppress("DEPRECATION")
+            val extensionArea = Extensions.getRootArea()
+
+            if (extensionArea.hasExtensionPoint(appExtension.extensionPointName)) {
                 return
+            }
 
             appExtension.registerExtensionPoint()
             instances.forEach { extension -> appExtension.registerExtension(extension, disposable) }
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DokkaResolutionFacade.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DokkaResolutionFacade.kt
index c0fafc25da..b278ef6ed3 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DokkaResolutionFacade.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/DokkaResolutionFacade.kt
@@ -75,6 +75,7 @@ class DokkaResolutionFacade(
                     if (key != element) {
                         throw UnsupportedOperationException()
                     }
+                    @Suppress("UNCHECKED_CAST")
                     return when {
                         slice == BindingContext.DECLARATION_TO_DESCRIPTOR -> descriptor as V
                         slice == BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER && (element as KtParameter).hasValOrVar() -> descriptor as V
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/JvmDependenciesIndexImpl.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/JvmDependenciesIndexImpl.kt
index 3632337a7d..c64f2fab2d 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/JvmDependenciesIndexImpl.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/JvmDependenciesIndexImpl.kt
@@ -20,7 +20,7 @@ import com.intellij.ide.highlighter.JavaClassFileType
 import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.util.containers.IntArrayList
+import it.unimi.dsi.fastutil.ints.IntArrayList
 import gnu.trove.THashMap
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -54,7 +54,7 @@ class JvmDependenciesIndexImpl(_roots: List<JavaRoot>) : JvmDependenciesIndex {
         Cache().apply {
             roots.indices.forEach(rootIndices::add)
             rootIndices.add(maxIndex)
-            rootIndices.trimToSize()
+            rootIndices.trim()
         }
     }
 
@@ -121,8 +121,8 @@ class JvmDependenciesIndexImpl(_roots: List<JavaRoot>) : JvmDependenciesIndex {
         // NOTE: indices manipulation instead of using caches.reversed() is here for performance reasons
         for (cacheIndex in caches.lastIndex downTo 0) {
             val cacheRootIndices = caches[cacheIndex].rootIndices
-            for (i in 0 until cacheRootIndices.size()) {
-                val rootIndex = cacheRootIndices[i]
+            for (i in 0 until cacheRootIndices.size) {
+                val rootIndex = cacheRootIndices.getInt(i)
                 if (rootIndex <= processedRootsUpTo) continue // roots with those indices have been processed by now
 
                 val directoryInRoot =
@@ -138,7 +138,12 @@ class JvmDependenciesIndexImpl(_roots: List<JavaRoot>) : JvmDependenciesIndex {
                     }
                 }
             }
-            processedRootsUpTo = if (cacheRootIndices.isEmpty) processedRootsUpTo else cacheRootIndices.get(cacheRootIndices.size() - 1)
+            processedRootsUpTo =
+                if (cacheRootIndices.isEmpty) {
+                    processedRootsUpTo
+                } else {
+                    cacheRootIndices.getInt(cacheRootIndices.size - 1)
+                }
         }
 
         if (request is FindClassRequest) {
@@ -160,7 +165,7 @@ class JvmDependenciesIndexImpl(_roots: List<JavaRoot>) : JvmDependenciesIndex {
             for (i in (fillCachesAfter + 1) until cachesPath.size) {
                 // we all know roots that contain this package by now
                 cachesPath[i].rootIndices.add(maxIndex)
-                cachesPath[i].rootIndices.trimToSize()
+                cachesPath[i].rootIndices.trim()
             }
             return null
         }
diff --git a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/TypeReferenceFactory.kt b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/TypeReferenceFactory.kt
index 336b7566b9..22660ecc66 100644
--- a/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/TypeReferenceFactory.kt
+++ b/kotlin-analysis/src/main/kotlin/org/jetbrains/dokka/analysis/TypeReferenceFactory.kt
@@ -23,7 +23,7 @@ fun TypeReference.Companion.from(d: ReceiverParameterDescriptor): TypeReference?
 fun TypeReference.Companion.from(d: ValueParameterDescriptor): TypeReference =
     fromPossiblyNullable(d.type, emptyList())
 
-fun TypeReference.Companion.from(p: PsiClass) = TypeReference
+fun TypeReference.Companion.from(@Suppress("UNUSED_PARAMETER") p: PsiClass) = TypeReference
 
 private fun TypeReference.Companion.fromPossiblyNullable(t: KotlinType, paramTrace: List<KotlinType>): TypeReference =
     fromPossiblyRecursive(t, paramTrace).let { if (t.isMarkedNullable) Nullable(it) else it }
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 95dcae4ec2..eeeea265b2 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 75617e0c25..d3006f3365 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 a3cbcc2e2b..ea87dce8a6 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 055594697d..7ce41866e2 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 b68413235c..dc5a95436c 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 ba4b41313b..642c01c3b8 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 7124577865..98cabd72e8 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 a9b998404e..58c601bc73 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 6239ad6b44..17e3cbcd98 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 4ca3d86175..946887991b 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 a1b5052df5..2e4b29ff51 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 c38edea864..85b082effc 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 918489638e..85ec1d07ff 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 57e0585869..3a4ff84d29 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 b44eb651b8..e5533a7e8c 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 664b828210..50580afc66 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 5bd152dcb8..164fa62da2 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 e566320ceb..d739991427 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 d1b8153de2..1d86f219ee 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 e7c45abd1e..13d4b4563b 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 e6acec92ca..efab9aba54 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 3b333445a6..c89234f803 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 3b0f6eef92..1a4bb33081 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 ac8efe6a76..fddd41e756 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 186fe9ee78..f141bb0685 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 59b1817a43..6a7b2d89a2 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 4b410f335a..46b13763b8 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 c77a78fb2e..3e5ceb75ba 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 8a8586eece..989b82eff1 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 65ac1224ef..e7f408f2c9 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 ad3b5d38b9..33ec237220 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 fd9fcc5d46..79e9f54867 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 9f74e2196f..1213727d0b 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 ecde2c77b3..7510e5416b 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 786e410d07..133229441d 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 61d45ae10d..a79c6b2008 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 bef4108c09..057b9e8592 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 1d721611f2..f8377e4140 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 10240a3f3b..0f8d7e798d 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 982d356aeb..e2331f5816 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 801213c2be..76c345b0e3 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 356e5772c9..592d7b0d66 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 fa1f668f16..1f5719eae3 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 28cb345388..d937c8410c 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/templates/AddToNavigationCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToNavigationCommandResolutionTest.kt
similarity index 100%
rename from plugins/templating/src/test/kotlin/templates/AddToNavigationCommandResolutionTest.kt
rename to plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToNavigationCommandResolutionTest.kt
diff --git a/plugins/templating/src/test/kotlin/templates/AddToSearchCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToSearchCommandResolutionTest.kt
similarity index 97%
rename from plugins/templating/src/test/kotlin/templates/AddToSearchCommandResolutionTest.kt
rename to plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToSearchCommandResolutionTest.kt
index d2ad7e0ca4..45c704694d 100644
--- a/plugins/templating/src/test/kotlin/templates/AddToSearchCommandResolutionTest.kt
+++ b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/AddToSearchCommandResolutionTest.kt
@@ -34,7 +34,7 @@ class AddToSearchCommandResolutionTest : TemplatingAbstractTest() {
     @ParameterizedTest
     @ValueSource(strings = ["pages.json"])
     fun `should merge navigation templates`(fileName: String) {
-        val (module1Navigation, module2Navigation) = setupTestDirectoriesWithContent(fileName)
+        setupTestDirectoriesWithContent(fileName)
 
         val outputDir = folder.root
         val configuration = dokkaConfiguration {
diff --git a/plugins/templating/src/test/kotlin/templates/SubstitutionCommandResolutionTest.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/SubstitutionCommandResolutionTest.kt
similarity index 100%
rename from plugins/templating/src/test/kotlin/templates/SubstitutionCommandResolutionTest.kt
rename to plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/SubstitutionCommandResolutionTest.kt
diff --git a/plugins/templating/src/test/kotlin/templates/TemplatingDokkaTestGenerator.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TemplatingDokkaTestGenerator.kt
similarity index 100%
rename from plugins/templating/src/test/kotlin/templates/TemplatingDokkaTestGenerator.kt
rename to plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TemplatingDokkaTestGenerator.kt
diff --git a/plugins/templating/src/test/kotlin/templates/TestTemplatingGeneration.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingGeneration.kt
similarity index 100%
rename from plugins/templating/src/test/kotlin/templates/TestTemplatingGeneration.kt
rename to plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingGeneration.kt
diff --git a/plugins/templating/src/test/kotlin/templates/TestTemplatingPlugin.kt b/plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingPlugin.kt
similarity index 100%
rename from plugins/templating/src/test/kotlin/templates/TestTemplatingPlugin.kt
rename to plugins/templating/src/test/kotlin/org/jetbrains/dokka/templates/TestTemplatingPlugin.kt
diff --git a/plugins/versioning/src/main/kotlin/versioning/DefaultPreviousDocumentationCopyPostAction.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/DefaultPreviousDocumentationCopyPostAction.kt
similarity index 100%
rename from plugins/versioning/src/main/kotlin/versioning/DefaultPreviousDocumentationCopyPostAction.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/DefaultPreviousDocumentationCopyPostAction.kt
diff --git a/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionCommandConsumer.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionCommandConsumer.kt
similarity index 100%
rename from plugins/versioning/src/main/kotlin/versioning/ReplaceVersionCommandConsumer.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionCommandConsumer.kt
diff --git a/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionsCommand.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionsCommand.kt
similarity index 79%
rename from plugins/versioning/src/main/kotlin/versioning/ReplaceVersionsCommand.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionsCommand.kt
index ad1edd2b95..66dd986027 100644
--- a/plugins/versioning/src/main/kotlin/versioning/ReplaceVersionsCommand.kt
+++ b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/ReplaceVersionsCommand.kt
@@ -18,8 +18,8 @@ class ReplaceVersionCommandHandler(context: DokkaContext) : CommandHandler {
 
     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))
+    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/versioning/VersioningConfiguration.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningConfiguration.kt
similarity index 100%
rename from plugins/versioning/src/main/kotlin/versioning/VersioningConfiguration.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningConfiguration.kt
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersioningPlugin.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningPlugin.kt
similarity index 100%
rename from plugins/versioning/src/main/kotlin/versioning/VersioningPlugin.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningPlugin.kt
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersioningStorage.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningStorage.kt
similarity index 100%
rename from plugins/versioning/src/main/kotlin/versioning/VersioningStorage.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersioningStorage.kt
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersionsNavigationCreator.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsNavigationCreator.kt
similarity index 100%
rename from plugins/versioning/src/main/kotlin/versioning/VersionsNavigationCreator.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsNavigationCreator.kt
diff --git a/plugins/versioning/src/main/kotlin/versioning/VersionsOrdering.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsOrdering.kt
similarity index 100%
rename from plugins/versioning/src/main/kotlin/versioning/VersionsOrdering.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/VersionsOrdering.kt
diff --git a/plugins/versioning/src/main/kotlin/versioning/htmlPreprocessors.kt b/plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/htmlPreprocessors.kt
similarity index 100%
rename from plugins/versioning/src/main/kotlin/versioning/htmlPreprocessors.kt
rename to plugins/versioning/src/main/kotlin/org/jetbrains/dokka/versioning/htmlPreprocessors.kt
diff --git a/runners/cli/src/main/kotlin/cli/main.kt b/runners/cli/src/main/kotlin/org/jetbrains/dokka/main.kt
similarity index 99%
rename from runners/cli/src/main/kotlin/cli/main.kt
rename to runners/cli/src/main/kotlin/org/jetbrains/dokka/main.kt
index c2a68d68bf..aca57f7ede 100644
--- a/runners/cli/src/main/kotlin/cli/main.kt
+++ b/runners/cli/src/main/kotlin/org/jetbrains/dokka/main.kt
@@ -281,6 +281,7 @@ private fun parseSourceSet(moduleName: String, args: Array<String>): DokkaConfig
             .toMutableSet()
         override val samples = samples.toMutableSet()
         override val includes = includes.toMutableSet()
+        @Deprecated("Use [documentedVisibilities] property for a more flexible control over documented visibilities")
         override val includeNonPublic = includeNonPublic
         override val reportUndocumented = reportUndocumented
         override val skipEmptyPackages = skipEmptyPackages
diff --git a/runners/cli/src/test/kotlin/cli/CliTest.kt b/runners/cli/src/test/kotlin/org/jetbrains/dokka/CliTest.kt
similarity index 97%
rename from runners/cli/src/test/kotlin/cli/CliTest.kt
rename to runners/cli/src/test/kotlin/org/jetbrains/dokka/CliTest.kt
index 967003dca8..557fe36b4b 100644
--- a/runners/cli/src/test/kotlin/cli/CliTest.kt
+++ b/runners/cli/src/test/kotlin/org/jetbrains/dokka/CliTest.kt
@@ -1,10 +1,10 @@
 package org.jetbrains.dokka
 
-import junit.framework.Assert.assertTrue
 import org.junit.Test
 import java.lang.IllegalStateException
 import java.nio.file.Paths
 import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
 class CliIntegrationTest {
 
diff --git a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilder.kt b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilder.kt
index abaa25369c..21f0e268c1 100644
--- a/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilder.kt
+++ b/runners/gradle-plugin/src/main/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilder.kt
@@ -11,7 +11,6 @@ import org.gradle.api.provider.SetProperty
 import org.gradle.api.tasks.*
 import org.gradle.kotlin.dsl.listProperty
 import org.gradle.kotlin.dsl.setProperty
-import org.gradle.util.ConfigureUtil
 import org.jetbrains.dokka.*
 import java.io.File
 import java.net.URL
@@ -156,8 +155,9 @@ open class GradleDokkaSourceSetBuilder(
         sourceRoot(project.file(path))
     }
 
+    @Suppress("DEPRECATION") // TODO [beresnev] ConfigureUtil will be removed in Gradle 8
     fun sourceLink(c: Closure<in GradleSourceLinkBuilder>) {
-        val configured = ConfigureUtil.configure(c, GradleSourceLinkBuilder(project))
+        val configured = org.gradle.util.ConfigureUtil.configure(c, GradleSourceLinkBuilder(project))
         sourceLinks.add(configured)
     }
 
@@ -167,8 +167,9 @@ open class GradleDokkaSourceSetBuilder(
         sourceLinks.add(sourceLink)
     }
 
+    @Suppress("DEPRECATION") // TODO [beresnev] ConfigureUtil will be removed in Gradle 8
     fun perPackageOption(c: Closure<in GradlePackageOptionsBuilder>) {
-        val configured = ConfigureUtil.configure(c, GradlePackageOptionsBuilder(project))
+        val configured = org.gradle.util.ConfigureUtil.configure(c, GradlePackageOptionsBuilder(project))
         perPackageOptions.add(configured)
     }
 
@@ -178,8 +179,9 @@ open class GradleDokkaSourceSetBuilder(
         perPackageOptions.add(option)
     }
 
+    @Suppress("DEPRECATION") // TODO [beresnev] ConfigureUtil will be removed in Gradle 8
     fun externalDocumentationLink(c: Closure<in GradleExternalDocumentationLinkBuilder>) {
-        val link = ConfigureUtil.configure(c, GradleExternalDocumentationLinkBuilder(project))
+        val link = org.gradle.util.ConfigureUtil.configure(c, GradleExternalDocumentationLinkBuilder(project))
         externalDocumentationLinks.add(link)
     }
 
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleTaskTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleTaskTest.kt
index 5ad33c57be..6e851326e0 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleTaskTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/DokkaMultiModuleTaskTest.kt
@@ -201,6 +201,8 @@ class DokkaMultiModuleTaskTest {
         val childTask = child.tasks.create<DokkaTask>("child")
 
         parentTask.addChildTask(childTask)
+
+        @Suppress("NAME_SHADOWING") // ¯\_(ツ)_/¯
         parentTask.fileLayout by DokkaMultiModuleFileLayout { parent, child ->
             parent.project.buildDir.resolve(child.name)
         }
diff --git a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilderTest.kt b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilderTest.kt
index 59b3591752..770d1af322 100644
--- a/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilderTest.kt
+++ b/runners/gradle-plugin/src/test/kotlin/org/jetbrains/dokka/gradle/GradleDokkaSourceSetBuilderTest.kt
@@ -148,6 +148,7 @@ class GradleDokkaSourceSetBuilderTest {
     }
 
     @Test
+    @Suppress("DEPRECATION")
     fun includeNonPublic() {
         val sourceSet = GradleDokkaSourceSetBuilder("", project)
         assertEquals(
diff --git a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
index de190db1d3..94eacdb51d 100644
--- a/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
+++ b/runners/maven-plugin/src/main/kotlin/DokkaMojo.kt
@@ -68,6 +68,7 @@ abstract class AbstractDokkaMojo(private val defaultDokkaPlugins: List<Dependenc
         override var matchingRegex: String = ".*"
 
         @Parameter
+        @Deprecated("Use [documentedVisibilities] property for a more flexible control over documented visibilities")
         override var includeNonPublic: Boolean = DokkaDefaults.includeNonPublic
 
         @Parameter
@@ -214,6 +215,7 @@ abstract class AbstractDokkaMojo(private val defaultDokkaPlugins: List<Dependenc
             jdkVersion = jdkVersion,
             sourceLinks = sourceLinks.map { SourceLinkDefinitionImpl(it.path, URL(it.url), it.lineSuffix) }.toSet(),
             perPackageOptions = perPackageOptions.map {
+                @Suppress("DEPRECATION") // for includeNonPublic, preserve backwards compatibility
                 PackageOptionsImpl(
                     matchingRegex = it.matchingRegex,
                     includeNonPublic = it.includeNonPublic,