Enable warnings as errors and fix all warnings (#2451)

* Enable warnings as errors and fix all warnings

* Enable skip-metadata-version-check compiler setting

12 files changed, 142 insertions, 118 deletions

diff --git a/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt b/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
index 75617e0c..d3006f33 100644
--- a/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
+++ b/plugins/base/src/main/kotlin/parsers/MarkdownParser.kt
@@ -74,7 +74,7 @@ open class MarkdownParser(
             ).flatMap { it.children }
         )
 
-    private fun horizontalRulesHandler(node: ASTNode) =
+    private fun horizontalRulesHandler() =
         DocTagsFromIElementFactory.getInstance(MarkdownTokenTypes.HORIZONTAL_RULE)
 
     private fun emphasisHandler(node: ASTNode) =
@@ -353,7 +353,7 @@ open class MarkdownParser(
             MarkdownElementTypes.ATX_5,
             MarkdownElementTypes.ATX_6,
             -> headersHandler(node)
-            MarkdownTokenTypes.HORIZONTAL_RULE -> horizontalRulesHandler(node)
+            MarkdownTokenTypes.HORIZONTAL_RULE -> horizontalRulesHandler()
             MarkdownElementTypes.STRONG -> strongHandler(node)
             MarkdownElementTypes.EMPH -> emphasisHandler(node)
             MarkdownElementTypes.FULL_REFERENCE_LINK,
diff --git a/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt b/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
index a3cbcc2e..ea87dce8 100644
--- a/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
+++ b/plugins/base/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
@@ -54,6 +54,7 @@ object DocTagsFromIElementFactory {
             MarkdownTokenTypes.HTML_BLOCK_CONTENT       -> Text(body.orEmpty(), params = params + contentTypeParam("html"))
             else                                        -> CustomDocTag(children, params, type.name)
         }.let {
+            @Suppress("UNCHECKED_CAST")
             when (it) {
                 is List<*> -> it as List<DocTag>
                 else -> listOf(it as DocTag)
diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 05559469..7ce41866 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -367,8 +367,6 @@ open class HtmlRenderer(
         pageContext: ContentPage
     ) = // TODO: extension point there
         if (node.isImage()) {
-            //TODO: add imgAttrs parsing
-            val imgAttrs = node.extra.allOfType<SimpleAttr>().joinAttr()
             img(src = node.address, alt = node.altText)
         } else {
             println("Unrecognized resource type: $node")
@@ -377,17 +375,16 @@ open class HtmlRenderer(
     private fun FlowContent.buildRow(
         node: ContentGroup,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<DisplaySourceSet>?,
-        style: Set<Style>
+        sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
         node.children
             .filter { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }
             .takeIf { it.isNotEmpty() }
             ?.let {
                 when (pageContext) {
-                    is MultimoduleRootPage -> buildRowForMultiModule(node, it, pageContext, sourceSetRestriction, style)
-                    is ModulePage -> buildRowForModule(node, it, pageContext, sourceSetRestriction, style)
-                    else -> buildRowForContent(node, it, pageContext, sourceSetRestriction, style)
+                    is MultimoduleRootPage -> buildRowForMultiModule(node, it, pageContext, sourceSetRestriction)
+                    is ModulePage -> buildRowForModule(node, it, pageContext, sourceSetRestriction)
+                    else -> buildRowForContent(node, it, pageContext, sourceSetRestriction)
                 }
             }
     }
@@ -396,8 +393,7 @@ open class HtmlRenderer(
         contextNode: ContentGroup,
         toRender: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<DisplaySourceSet>?,
-        style: Set<Style>
+        sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
         buildAnchor(contextNode)
         div(classes = "table-row") {
@@ -414,8 +410,7 @@ open class HtmlRenderer(
         contextNode: ContentGroup,
         toRender: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<DisplaySourceSet>?,
-        style: Set<Style>
+        sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
         buildAnchor(contextNode)
         div(classes = "table-row") {
@@ -440,8 +435,7 @@ open class HtmlRenderer(
         contextNode: ContentGroup,
         toRender: List<ContentNode>,
         pageContext: ContentPage,
-        sourceSetRestriction: Set<DisplaySourceSet>?,
-        style: Set<Style>
+        sourceSetRestriction: Set<DisplaySourceSet>?
     ) {
         buildAnchor(contextNode)
         div(classes = "table-row") {
@@ -551,7 +545,7 @@ open class HtmlRenderer(
             else -> div(classes = "table") {
                 node.extra.extraHtmlAttributes().forEach { attributes[it.extraKey] = it.extraValue }
                 node.children.forEach {
-                    buildRow(it, pageContext, sourceSetRestriction, node.style)
+                    buildRow(it, pageContext, sourceSetRestriction)
                 }
             }
         }
diff --git a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
index b6841323..dc5a9543 100644
--- a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
+++ b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
@@ -163,16 +163,23 @@ interface JvmSignatureUtils {
         }
     }
 
-    fun <T : Documentable> WithExtraProperties<T>.stylesIfDeprecated(sourceSetData: DokkaSourceSet): Set<TextStyle> =
-        if (extra[Annotations]?.directAnnotations?.get(sourceSetData)?.any {
-                it.dri == DRI("kotlin", "Deprecated")
-                        || it.dri == DRI("java.lang", "Deprecated")
-            } == true) setOf(TextStyle.Strikethrough) else emptySet()
-
-    infix fun DFunction.uses(t: DTypeParameter): Boolean {
-        val allDris: List<DRI> = (listOfNotNull(receiver?.dri, *receiver?.type?.drisOfAllNestedBounds?.toTypedArray() ?: emptyArray()) +
-                parameters.flatMap { listOf(it.dri) + it.type.drisOfAllNestedBounds })
-        return t.dri in allDris
+    fun <T : Documentable> WithExtraProperties<T>.stylesIfDeprecated(sourceSetData: DokkaSourceSet): Set<TextStyle> {
+        val directAnnotations = extra[Annotations]?.directAnnotations?.get(sourceSetData) ?: emptyList()
+        val hasAnyDeprecatedAnnotation =
+            directAnnotations.any { it.dri == DRI("kotlin", "Deprecated") || it.dri == DRI("java.lang", "Deprecated") }
+
+        return if (hasAnyDeprecatedAnnotation) setOf(TextStyle.Strikethrough) else emptySet()
+    }
+
+    infix fun DFunction.uses(typeParameter: DTypeParameter): Boolean {
+        val parameterDris = parameters.flatMap { listOf(it.dri) + it.type.drisOfAllNestedBounds }
+        val receiverDris =
+            listOfNotNull(
+                receiver?.dri,
+                *receiver?.type?.drisOfAllNestedBounds?.toTypedArray() ?: emptyArray()
+            )
+        val allDris = parameterDris + receiverDris
+        return typeParameter.dri in allDris
     }
 
     /**
diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
index ba4b4131..642c01c3 100644
--- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
+++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
@@ -13,10 +13,7 @@ import org.jetbrains.dokka.model.*
 import org.jetbrains.dokka.model.Nullable
 import org.jetbrains.dokka.model.TypeConstructor
 import org.jetbrains.dokka.model.properties.WithExtraProperties
-import org.jetbrains.dokka.pages.ContentKind
-import org.jetbrains.dokka.pages.ContentNode
-import org.jetbrains.dokka.pages.TextStyle
-import org.jetbrains.dokka.pages.TokenStyle
+import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
 import org.jetbrains.dokka.plugability.querySingle
@@ -96,12 +93,16 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             }
         }
 
-    private fun actualTypealiasedSignature(c: DClasslike, sourceSet: DokkaSourceSet, aliasedType: Bound) =
-        contentBuilder.contentFor(
+    private fun actualTypealiasedSignature(c: DClasslike, sourceSet: DokkaSourceSet, aliasedType: Bound): ContentGroup {
+        @Suppress("UNCHECKED_CAST")
+        val deprecationStyles = (c as? WithExtraProperties<out Documentable>)
+            ?.stylesIfDeprecated(sourceSet)
+            ?: emptySet()
+
+        return contentBuilder.contentFor(
             c,
             ContentKind.Symbol,
-            setOf(TextStyle.Monospace) + ((c as? WithExtraProperties<out Documentable>)?.stylesIfDeprecated(sourceSet)
-                ?: emptySet()),
+            setOf(TextStyle.Monospace) + deprecationStyles,
             sourceSets = setOf(sourceSet)
         ) {
             keyword("actual ")
@@ -110,15 +111,24 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             operator(" = ")
             signatureForProjection(aliasedType)
         }
+    }
 
-    @Suppress("UNCHECKED_CAST")
-    private fun <T : DClasslike> classlikeSignature(c: T): List<ContentNode> =
-        c.sourceSets.map { sourceSetData ->
-            (c as? WithExtraProperties<out DClasslike>)?.extra?.get(ActualTypealias)?.underlyingType?.get(sourceSetData)
-                ?.let {
-                    actualTypealiasedSignature(c, sourceSetData, it)
-                } ?: regularSignature(c, sourceSetData)
+    private fun <T : DClasslike> classlikeSignature(c: T): List<ContentNode> {
+        @Suppress("UNCHECKED_CAST")
+        val typeAliasUnderlyingType = (c as? WithExtraProperties<out DClasslike>)
+            ?.extra
+            ?.get(ActualTypealias)
+            ?.underlyingType
+
+        return c.sourceSets.map { sourceSetData ->
+            val sourceSetType = typeAliasUnderlyingType?.get(sourceSetData)
+            if (sourceSetType == null) {
+                regularSignature(c, sourceSetData)
+            } else {
+                actualTypealiasedSignature(c, sourceSetData, sourceSetType)
+            }
         }
+    }
 
     private fun <T : Documentable> PageContentBuilder.DocumentableContentBuilder.defaultValueAssign(
         d: WithExtraProperties<T>,
@@ -134,27 +144,33 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         }
     }
 
-    private fun regularSignature(c: DClasslike, sourceSet: DokkaSourceSet) =
-        contentBuilder.contentFor(
+    private fun regularSignature(c: DClasslike, sourceSet: DokkaSourceSet): ContentGroup {
+        @Suppress("UNCHECKED_CAST")
+        val deprecationStyles = (c as? WithExtraProperties<out Documentable>)
+            ?.stylesIfDeprecated(sourceSet)
+            ?: emptySet()
+
+        return contentBuilder.contentFor(
             c,
             ContentKind.Symbol,
-            setOf(TextStyle.Monospace) + ((c as? WithExtraProperties<out Documentable>)?.stylesIfDeprecated(sourceSet)
-                ?: emptySet()),
+            setOf(TextStyle.Monospace) + deprecationStyles,
             sourceSets = setOf(sourceSet)
         ) {
             annotationsBlock(c)
             c.visibility[sourceSet]?.takeIf { it !in ignoredVisibilities }?.name?.let { keyword("$it ") }
             if (c.isExpectActual) keyword(if (sourceSet == c.expectPresentInSet) "expect " else "actual ")
             if (c is DClass) {
-               val modifier = if (c.modifier[sourceSet] !in ignoredModifiers)
+                val modifier =
+                    if (c.modifier[sourceSet] !in ignoredModifiers) {
                         when {
                             c.extra[AdditionalModifiers]?.content?.get(sourceSet)?.contains(ExtraModifiers.KotlinOnlyModifiers.Data) == true -> ""
                             c.modifier[sourceSet] is JavaModifier.Empty -> "${KotlinModifier.Open.name} "
-                            else -> c.modifier[sourceSet]?.name?.let { "$it " } ?: ""
+                            else -> c.modifier[sourceSet]?.name?.let { "$it " }
                         }
-                    else
-                        ""
-                modifier.takeIf { it.isNotEmpty() }?.let { keyword(it) }
+                    } else {
+                        null
+                    }
+                modifier?.takeIf { it.isNotEmpty() }?.let { keyword(it) }
             }
             when (c) {
                 is DClass -> {
@@ -232,6 +248,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                 }
             }
         }
+    }
 
     /**
      * An example would be a primary constructor `class A(val s: String)`,
diff --git a/plugins/base/src/main/kotlin/templating/jsonMapperForPlugins.kt b/plugins/base/src/main/kotlin/templating/jsonMapperForPlugins.kt
index 71245778..98cabd72 100644
--- a/plugins/base/src/main/kotlin/templating/jsonMapperForPlugins.kt
+++ b/plugins/base/src/main/kotlin/templating/jsonMapperForPlugins.kt
@@ -49,6 +49,7 @@ private object FileSerializer : StdScalarSerializer<File>(File::class.java) {
     }
 }
 
+@Suppress("DEPRECATION") // for TypeFactory constructor, no way to use non-deprecated one, it's essentially identical
 private class PluginTypeFactory: TypeFactory(null) {
     override fun findClass(className: String): Class<out Any>? =
         Class.forName(className, true, DokkaBase::class.java.classLoader) ?: super.findClass(className)
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
index a9b99840..58c601bc 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/ActualTypealiasAdder.kt
@@ -66,7 +66,7 @@ class ActualTypealiasAdder : DocumentableTransformer {
         elements.map { element ->
             if (element.expectPresentInSet != null) {
                 typealiases[element.dri]?.let { ta ->
-                    element.withNewExtras(element.extra + ActualTypealias(ta.underlyingType)).let {
+                    val merged = element.withNewExtras(element.extra + ActualTypealias(ta.underlyingType)).let {
                         when(it) {
                             is DClass -> it.copy(sourceSets = element.sourceSets + ta.sourceSets)
                             is DEnum ->  it.copy(sourceSets = element.sourceSets + ta.sourceSets)
@@ -75,7 +75,9 @@ class ActualTypealiasAdder : DocumentableTransformer {
                             is DAnnotation -> it.copy(sourceSets = element.sourceSets + ta.sourceSets)
                             else -> throw IllegalStateException("${it::class.qualifiedName} ${it.name} cannot have copy its sourceSets")
                         }
-                    } as T
+                    }
+                    @Suppress("UNCHECKED_CAST")
+                    merged as T
                 } ?: element
             } else {
                 element
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
index 6239ad6b..17e3cbcd 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DefaultDocumentableMerger.kt
@@ -49,7 +49,7 @@ internal class DefaultDocumentableMerger(val context: DokkaContext) : Documentab
 
         fun mergeClashingElements(elements: List<Pair<T, Set<DokkaConfiguration.DokkaSourceSet>>>): List<T> =
             elements.groupBy { it.first.name }.values.flatMap { listOfDocumentableToSSIds ->
-                listOfDocumentableToSSIds.map { (documentable, sourceSets) ->
+                val merged = listOfDocumentableToSSIds.map { (documentable, sourceSets) ->
                     when (documentable) {
                         is DClass -> documentable.copy(
                             extra = documentable.extra + ClashingDriIdentifier(
@@ -88,7 +88,9 @@ internal class DefaultDocumentableMerger(val context: DokkaContext) : Documentab
                         )
                         else -> documentable
                     }
-                } as List<T>
+                }
+                @Suppress("UNCHECKED_CAST")
+                merged as List<T>
             }
 
 
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
index 4ca3d861..94688799 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/DocumentableVisibilityFilterTransformer.kt
@@ -35,10 +35,12 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
                 packageOptions.firstOrNull { Regex(it.matchingRegex).matches(name) }
             }
 
-            val (documentedVisibilities, includeNonPublic) = when {
-                packageOpts != null -> packageOpts.documentedVisibilities to packageOpts.includeNonPublic
-                else -> globalOptions.documentedVisibilities to globalOptions.includeNonPublic
-            }
+            val (documentedVisibilities, includeNonPublic) =
+                @Suppress("DEPRECATION") // for includeNonPublic, preserve backwards compatibility
+                when {
+                    packageOpts != null -> packageOpts.documentedVisibilities to packageOpts.includeNonPublic
+                    else -> globalOptions.documentedVisibilities to globalOptions.includeNonPublic
+                }
 
             // if `documentedVisibilities` is explicitly overridden by the user (i.e. not default value by reference),
             // deprecated `includeNonPublic` should not be taken into account, so that only one setting prevails
@@ -176,7 +178,7 @@ class DocumentableVisibilityFilterTransformer(val context: DokkaContext) : PreMe
         ): Pair<Boolean, List<DProperty>> {
 
             val modifier: (DProperty, Set<DokkaSourceSet>) -> Pair<Boolean, DProperty> =
-                { original, filteredPlatforms ->
+                { original, _ ->
                     val setter = original.setter?.let { filterFunctions(listOf(it), additionalConditionAccessors) }
                     val getter = original.getter?.let { filterFunctions(listOf(it), additionalConditionAccessors) }
 
diff --git a/plugins/base/src/main/kotlin/transformers/documentables/InheritedEntriesDocumentableFilterTransformer.kt b/plugins/base/src/main/kotlin/transformers/documentables/InheritedEntriesDocumentableFilterTransformer.kt
index a1b5052d..2e4b29ff 100644
--- a/plugins/base/src/main/kotlin/transformers/documentables/InheritedEntriesDocumentableFilterTransformer.kt
+++ b/plugins/base/src/main/kotlin/transformers/documentables/InheritedEntriesDocumentableFilterTransformer.kt
@@ -6,8 +6,12 @@ import org.jetbrains.dokka.plugability.DokkaContext
 
 class InheritedEntriesDocumentableFilterTransformer(context: DokkaContext) :
     SuppressedByConditionDocumentableFilterTransformer(context) {
-    override fun shouldBeSuppressed(d: Documentable): Boolean =
-        context.configuration.suppressInheritedMembers && (d as? WithExtraProperties<Documentable>)?.extra?.get(
-            InheritedMember
-        )?.inheritedFrom?.any { entry -> entry.value != null } ?: false
+
+    override fun shouldBeSuppressed(d: Documentable): Boolean {
+        @Suppress("UNCHECKED_CAST")
+        val inheritedMember = (d as? WithExtraProperties<Documentable>)?.extra?.get(InheritedMember)
+        val containsInheritedFrom = inheritedMember?.inheritedFrom?.any { entry -> entry.value != null } ?: false
+
+        return context.configuration.suppressInheritedMembers && containsInheritedFrom
+    }
 }
\ No newline at end of file
diff --git a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
index c38edea8..85b082ef 100644
--- a/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
+++ b/plugins/base/src/main/kotlin/transformers/pages/comments/DocTagToContentConverter.kt
@@ -15,17 +15,18 @@ open class DocTagToContentConverter : CommentsToContentConverter {
         dci: DCI,
         sourceSets: Set<DokkaSourceSet>,
         styles: Set<Style>,
-        extra: PropertyContainer<ContentNode>
+        extras: PropertyContainer<ContentNode>
     ): List<ContentNode> {
 
         fun buildChildren(docTag: DocTag, newStyles: Set<Style> = emptySet(), newExtras: SimpleAttr? = null) =
             docTag.children.flatMap {
-                buildContent(it, dci, sourceSets, styles + newStyles, newExtras?.let { extra + it } ?: extra)
+                buildContent(it, dci, sourceSets, styles + newStyles, newExtras?.let { extras + it } ?: extras)
             }
 
         fun buildTableRows(rows: List<DocTag>, newStyle: Style): List<ContentGroup> =
             rows.flatMap {
-                buildContent(it, dci, sourceSets, styles + newStyle, extra) as List<ContentGroup>
+                @Suppress("UNCHECKED_CAST")
+                buildContent(it, dci, sourceSets, styles + newStyle, extras) as List<ContentGroup>
             }
 
         fun buildHeader(level: Int) =
@@ -70,7 +71,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
             is Ul -> buildList(false)
             is Ol -> buildList(true, start = docTag.params["start"]?.toInt() ?: 1)
             is Li -> listOf(
-                ContentGroup(buildChildren(docTag), dci, sourceSets.toDisplaySourceSets(), styles, extra)
+                ContentGroup(buildChildren(docTag), dci, sourceSets.toDisplaySourceSets(), styles, extras)
             )
             is Dl -> buildList(false, newStyles = setOf(ListStyle.DescriptionList))
             is Dt -> listOf(
@@ -98,7 +99,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                     dci,
                     sourceSets.toDisplaySourceSets(),
                     styles + setOf(TextStyle.Paragraph),
-                    extra
+                    extras
                 )
             )
             is A -> listOf(
@@ -147,7 +148,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                     dci = dci,
                     sourceSets = sourceSets.toDisplaySourceSets(),
                     style = styles,
-                    extra = extra
+                    extra = extras
                 )
             )
             is HorizontalRule -> listOf(
@@ -164,7 +165,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                     dci,
                     sourceSets.toDisplaySourceSets(),
                     styles,
-                    extra + HtmlContent.takeIf { docTag.params["content-type"] == "html" }
+                    extras + HtmlContent.takeIf { docTag.params["content-type"] == "html" }
                 )
             )
             is Strikethrough -> buildChildren(docTag, setOf(TextStyle.Strikethrough))
@@ -182,7 +183,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                                     dci,
                                     sourceSets.toDisplaySourceSets(),
                                     styles,
-                                    extra
+                                    extras
                                 )
                             },
                             buildTableRows(body.filterIsInstance<Tr>(), CommentTable),
@@ -208,7 +209,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
             is Tr -> listOf(
                 ContentGroup(
                     docTag.children.map {
-                        ContentGroup(buildChildren(it), dci, sourceSets.toDisplaySourceSets(), styles, extra)
+                        ContentGroup(buildChildren(it), dci, sourceSets.toDisplaySourceSets(), styles, extras)
                     },
                     dci,
                     sourceSets.toDisplaySourceSets(),
@@ -230,7 +231,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                         dci,
                         sourceSets.toDisplaySourceSets(),
                         styles,
-                        extra = extra
+                        extra = extras
                     )
                 )
             } else {
@@ -242,7 +243,7 @@ open class DocTagToContentConverter : CommentsToContentConverter {
                     dci,
                     sourceSets.toDisplaySourceSets(),
                     styles + ContentStyle.Caption,
-                    extra = extra
+                    extra = extras
                 )
             )
 
diff --git a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
index 91848963..85ec1d07 100644
--- a/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
+++ b/plugins/base/src/main/kotlin/translators/descriptors/DefaultDescriptorToDocumentableTranslator.kt
@@ -14,7 +14,6 @@ import org.jetbrains.dokka.analysis.from
 import org.jetbrains.dokka.base.DokkaBase
 import org.jetbrains.dokka.base.parsers.MarkdownParser
 import org.jetbrains.dokka.base.translators.psi.parsers.JavadocParser
-import org.jetbrains.dokka.base.translators.psi.DefaultPsiToDocumentableTranslator
 import org.jetbrains.dokka.base.translators.typeConstructorsBeingExceptions
 import org.jetbrains.dokka.base.translators.unquotedValue
 import org.jetbrains.dokka.links.*
@@ -96,8 +95,7 @@ class DefaultDescriptorToDocumentableTranslator(
         return DokkaDescriptorVisitor(sourceSet, kotlinAnalysis[sourceSet].facade, context.logger).run {
             packageFragments.mapNotNull { it.safeAs<PackageFragmentDescriptor>() }.parallelMap {
                 visitPackageFragmentDescriptor(
-                    it,
-                    DRIWithPlatformInfo(DRI.topLevel, emptyMap())
+                    it
                 )
             }
         }.let {
@@ -145,20 +143,17 @@ private class DokkaDescriptorVisitor(
 
     private fun <T> T.toSourceSetDependent() = if (this != null) mapOf(sourceSet to this) else emptyMap()
 
-    suspend fun visitPackageFragmentDescriptor(
-        descriptor: PackageFragmentDescriptor,
-        parent: DRIWithPlatformInfo
-    ): DPackage {
+    suspend fun visitPackageFragmentDescriptor(descriptor: PackageFragmentDescriptor): DPackage {
         val name = descriptor.fqName.asString().takeUnless { it.isBlank() } ?: ""
         val driWithPlatform = DRI(packageName = name).withEmptyInfo()
         val scope = descriptor.getMemberScope()
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind(true)
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
-            val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases(driWithPlatform) }
+            val typealiases = async { descriptorsWithKind.typealiases.visitTypealiases() }
 
             DPackage(
                 dri = driWithPlatform.dri,
@@ -191,8 +186,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
             val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
 
@@ -232,8 +227,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
 
             DObject(
@@ -271,8 +266,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
             val constructors =
                 async { descriptor.constructors.parallelMap { visitConstructorDescriptor(it, driWithPlatform) } }
@@ -311,8 +306,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
 
             DEnumEntry(
@@ -342,8 +337,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
             val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
             val constructors =
@@ -385,8 +380,8 @@ private class DokkaDescriptorVisitor(
         return coroutineScope {
             val descriptorsWithKind = scope.getDescriptorsWithKind()
 
-            val functions = async { descriptorsWithKind.functions.visitFunctions(driWithPlatform) }
-            val properties = async { descriptorsWithKind.properties.visitProperties(driWithPlatform) }
+            val functions = async { descriptorsWithKind.functions.visitFunctions() }
+            val properties = async { descriptorsWithKind.properties.visitProperties() }
             val classlikes = async { descriptorsWithKind.classlikes.visitClasslikes(driWithPlatform) }
             val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
             val constructors = async {
@@ -426,10 +421,7 @@ private class DokkaDescriptorVisitor(
         }
     }
 
-    private suspend fun visitPropertyDescriptor(
-        originalDescriptor: PropertyDescriptor,
-        parent: DRIWithPlatformInfo
-    ): DProperty {
+    private suspend fun visitPropertyDescriptor(originalDescriptor: PropertyDescriptor): DProperty {
         val (dri, inheritedFrom) = originalDescriptor.createDRI()
         val descriptor = originalDescriptor.getConcreteDescriptor()
         val isExpect = descriptor.isExpect
@@ -481,10 +473,7 @@ private class DokkaDescriptorVisitor(
         else
             overriddenDescriptors.first().createDRI(DRI.from(this))
 
-    private suspend fun visitFunctionDescriptor(
-        originalDescriptor: FunctionDescriptor,
-        parent: DRIWithPlatformInfo
-    ): DFunction {
+    private suspend fun visitFunctionDescriptor(originalDescriptor: FunctionDescriptor): DFunction {
         val (dri, inheritedFrom) = originalDescriptor.createDRI()
         val descriptor = originalDescriptor.getConcreteDescriptor()
         val isExpect = descriptor.isExpect
@@ -675,7 +664,7 @@ private class DokkaDescriptorVisitor(
         }
     }
 
-    private suspend fun visitTypeAliasDescriptor(descriptor: TypeAliasDescriptor, parent: DRIWithPlatformInfo?) =
+    private suspend fun visitTypeAliasDescriptor(descriptor: TypeAliasDescriptor) =
         with(descriptor) {
             coroutineScope {
                 val generics = async { descriptor.declaredTypeParameters.parallelMap { it.toVariantTypeParameter() } }
@@ -742,6 +731,7 @@ private class DokkaDescriptorVisitor(
             }
         }
 
+        @Suppress("UNCHECKED_CAST")
         return DescriptorsWithKind(
             (groupedDescriptors[FunctionDescriptor::class] ?: emptyList()) as List<FunctionDescriptor>,
             (groupedDescriptors[PropertyDescriptor::class] ?: emptyList()) as List<PropertyDescriptor>,
@@ -751,17 +741,17 @@ private class DokkaDescriptorVisitor(
         )
     }
 
-    private suspend fun List<FunctionDescriptor>.visitFunctions(parent: DRIWithPlatformInfo): List<DFunction> =
-        coroutineScope { parallelMap { visitFunctionDescriptor(it, parent) } }
+    private suspend fun List<FunctionDescriptor>.visitFunctions(): List<DFunction> =
+        coroutineScope { parallelMap { visitFunctionDescriptor(it) } }
 
-    private suspend fun List<PropertyDescriptor>.visitProperties(parent: DRIWithPlatformInfo): List<DProperty> =
-        coroutineScope { parallelMap { visitPropertyDescriptor(it, parent) } }
+    private suspend fun List<PropertyDescriptor>.visitProperties(): List<DProperty> =
+        coroutineScope { parallelMap { visitPropertyDescriptor(it) } }
 
     private suspend fun List<ClassDescriptor>.visitClasslikes(parent: DRIWithPlatformInfo): List<DClasslike> =
         coroutineScope { parallelMap { visitClassDescriptor(it, parent) } }
 
-    private suspend fun List<TypeAliasDescriptor>.visitTypealiases(parent: DRIWithPlatformInfo): List<DTypeAlias> =
-        coroutineScope { parallelMap { visitTypeAliasDescriptor(it, parent) } }
+    private suspend fun List<TypeAliasDescriptor>.visitTypealiases(): List<DTypeAlias> =
+        coroutineScope { parallelMap { visitTypeAliasDescriptor(it) } }
 
     private suspend fun List<ClassDescriptor>.visitEnumEntries(parent: DRIWithPlatformInfo): List<DEnumEntry> =
         coroutineScope { parallelMap { visitEnumEntryDescriptor(it, parent) } }
@@ -972,7 +962,7 @@ private class DokkaDescriptorVisitor(
 
     private fun ConstantValue<*>.toValue(): AnnotationParameterValue = when (this) {
         is ConstantsAnnotationValue -> AnnotationValue(value.toAnnotation())
-        is ConstantsArrayValue -> ArrayValue(value.mapNotNull { it.toValue() })
+        is ConstantsArrayValue -> ArrayValue(value.map { it.toValue() })
         is ConstantsEnumValue -> EnumValue(
             fullEnumEntryName(),
             DRI(enumClassId.packageFqName.asString(), fullEnumEntryName())
@@ -1005,9 +995,7 @@ private class DokkaDescriptorVisitor(
     private fun AnnotationDescriptor.toAnnotation(scope: Annotations.AnnotationScope = Annotations.AnnotationScope.DIRECT): Annotations.Annotation =
         Annotations.Annotation(
             DRI.from(annotationClass as DeclarationDescriptor),
-            allValueArguments.map { it.key.asString() to it.value.toValue() }.filter {
-                it.second != null
-            }.toMap(),
+            allValueArguments.map { it.key.asString() to it.value.toValue() }.toMap(),
             mustBeDocumented(),
             scope
         )
@@ -1027,9 +1015,14 @@ private class DokkaDescriptorVisitor(
         }
     }
 
-    private fun <T : CallableMemberDescriptor> T.getConcreteDescriptor(): T =
-        if (kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) this
-        else overriddenDescriptors.first().getConcreteDescriptor() as T
+    private fun <T : CallableMemberDescriptor> T.getConcreteDescriptor(): T {
+        return if (kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+            this
+        } else {
+            @Suppress("UNCHECKED_CAST")
+            overriddenDescriptors.first().getConcreteDescriptor() as T
+        }
+    }
 
     private fun ValueParameterDescriptor.getDefaultValue(): Expression? =
         ((source as? KotlinSourceElement)?.psi as? KtParameter)?.defaultValue?.toDefaultValueExpression()