Merge pull request #2066 from Kotlin/webhelp-like-frontend

Webhelp like frontend

2 files changed, 115 insertions, 77 deletions

diff --git a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
index d17fa276..94af96e2 100644
--- a/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
+++ b/plugins/base/src/main/kotlin/signatures/JvmSignatureUtils.kt
@@ -8,7 +8,6 @@ import org.jetbrains.dokka.pages.*
 import org.jetbrains.dokka.DokkaConfiguration.DokkaSourceSet
 import org.jetbrains.dokka.base.signatures.KotlinSignatureUtils.drisOfAllNestedBounds
 import org.jetbrains.dokka.model.AnnotationTarget
-import org.jetbrains.dokka.model.doc.DocumentationNode
 
 interface JvmSignatureUtils {
 
@@ -80,21 +79,22 @@ interface JvmSignatureUtils {
 
         when (renderAtStrategy) {
             is All, is OnlyOnce -> {
-                text("@")
                 when(a.scope) {
-                    Annotations.AnnotationScope.GETTER -> text("get:")
-                    Annotations.AnnotationScope.SETTER -> text("set:")
+                    Annotations.AnnotationScope.GETTER -> text("@get:", styles = mainStyles + TokenStyle.Annotation)
+                    Annotations.AnnotationScope.SETTER -> text("@set:", styles = mainStyles + TokenStyle.Annotation)
+                    else -> text("@", styles = mainStyles + TokenStyle.Annotation)
                 }
+                link(a.dri.classNames!!, a.dri, styles = mainStyles + TokenStyle.Annotation)
             }
-            is Never -> Unit
+            is Never -> link(a.dri.classNames!!, a.dri)
         }
-        link(a.dri.classNames!!, a.dri)
         val isNoWrappedBrackets = a.params.entries.isEmpty() && renderAtStrategy is OnlyOnce
         listParams(
             a.params.entries,
             if (isNoWrappedBrackets) null else Pair('(', ')')
         ) {
-            text(it.key + " = ")
+            text(it.key)
+            text(" = ", styles = mainStyles + TokenStyle.Operator)
             when (renderAtStrategy) {
                 is All -> All
                 is Never, is OnlyOnce -> Never
@@ -116,8 +116,9 @@ interface JvmSignatureUtils {
         }
         is EnumValue -> link(a.enumName, a.enumDri)
         is ClassValue -> link(a.className + classExtension, a.classDRI)
-        is StringValue -> group(styles = setOf(TextStyle.Breakable)) { text( "\"${a.text()}\"") }
-        is LiteralValue -> group(styles = setOf(TextStyle.Breakable)) { text(a.text()) }
+        is StringValue -> group(styles = setOf(TextStyle.Breakable)) { stringLiteral( "\"${a.text()}\"") }
+        is BooleanValue -> group(styles = setOf(TextStyle.Breakable)) { booleanLiteral(a.value) }
+        is LiteralValue -> group(styles = setOf(TextStyle.Breakable)) { constant(a.text()) }
     }
 
     private fun<T> PageContentBuilder.DocumentableContentBuilder.listParams(
@@ -125,14 +126,14 @@ interface JvmSignatureUtils {
         listBrackets: Pair<Char, Char>?,
         outFn: PageContentBuilder.DocumentableContentBuilder.(T) -> Unit
     ) {
-        listBrackets?.let{ text(it.first.toString()) }
+        listBrackets?.let{ punctuation(it.first.toString()) }
         params.forEachIndexed { i, it ->
             group(styles = setOf(TextStyle.BreakableAfter)) {
                 this.outFn(it)
-                if (i != params.size - 1) text(", ")
+                if (i != params.size - 1) punctuation(", ")
             }
         }
-        listBrackets?.let{ text(it.second.toString()) }
+        listBrackets?.let{ punctuation(it.second.toString()) }
     }
 
     fun PageContentBuilder.DocumentableContentBuilder.annotationsBlockWithIgnored(
diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
index e5f0ae97..8db37012 100644
--- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
+++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
@@ -15,6 +15,7 @@ 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.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.plugin
 import org.jetbrains.dokka.plugability.querySingle
@@ -60,7 +61,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                         it !in ignoredExtraModifiers || entry.key.analysisPlatform in (platformSpecificModifiers[it]
                             ?: emptySet())
                     }
-                }
+                }, styles = mainStyles + TokenStyle.Keyword
         ) {
             it.toSignatureString()
         }
@@ -78,8 +79,15 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                     annotationsBlock(e)
                     link(e.name, e.dri, styles = emptySet())
                     e.extra[ConstructorValues]?.let { constructorValues ->
-                        constructorValues.values[it]
-                        text(constructorValues.values[it]?.joinToString(prefix = "(", postfix = ")") ?: "")
+                        constructorValues.values[it]?.let { values ->
+                            punctuation("(")
+                            list(
+                                elements = values,
+                                separator = ", ",
+                                separatorStyles = mainStyles + TokenStyle.Punctuation,
+                            ) { highlightValue(it) }
+                            punctuation(")")
+                        }
                     }
                 }
             }
@@ -93,9 +101,9 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                 ?: emptySet()),
             sourceSets = setOf(sourceSet)
         ) {
-            text("typealias ")
+            keyword("typealias ")
             link(c.name.orEmpty(), c.dri)
-            text(" = ")
+            operator(" = ")
             signatureForProjection(aliasedType)
         }
 
@@ -118,10 +126,9 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             sourceSets = setOf(sourceSet)
         ) {
             annotationsBlock(c)
-            text(c.visibility[sourceSet]?.takeIf { it !in ignoredVisibilities }?.name?.let { "$it " } ?: "")
+            c.visibility[sourceSet]?.takeIf { it !in ignoredVisibilities }?.name?.let { keyword("$it ") }
             if (c is DClass) {
-                text(
-                    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} "
@@ -129,33 +136,35 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                         }
                     else
                         ""
-                )
+                modifier.takeIf { it.isNotEmpty() }?.let { keyword(it) }
             }
             when (c) {
                 is DClass -> {
                     processExtraModifiers(c)
-                    text("class ")
+                    keyword("class ")
                 }
                 is DInterface -> {
                     processExtraModifiers(c)
-                    text("interface ")
+                    keyword("interface ")
                 }
                 is DEnum -> {
                     processExtraModifiers(c)
-                    text("enum ")
+                    keyword("enum ")
                 }
                 is DObject -> {
                     processExtraModifiers(c)
-                    text("object ")
+                    keyword("object ")
                 }
                 is DAnnotation -> {
                     processExtraModifiers(c)
-                    text("annotation class ")
+                    keyword("annotation class ")
                 }
             }
             link(c.name!!, c.dri)
             if (c is WithGenerics) {
-                list(c.generics, prefix = "<", suffix = ">") {
+                list(c.generics, prefix = "<", suffix = ">",
+                    separatorStyles = mainStyles + TokenStyle.Punctuation,
+                    surroundingCharactersStyle = mainStyles + TokenStyle.Operator) {
                     annotationsInline(it)
                     +buildSignature(it)
                 }
@@ -166,18 +175,20 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                     if (pConstructor.annotations().values.any { it.isNotEmpty() }) {
                         text(nbsp.toString())
                         annotationsInline(pConstructor)
-                        text("constructor")
+                        keyword("constructor")
                     }
                     list(
-                        pConstructor.parameters,
-                        "(",
-                        ")",
-                        ", ",
-                        pConstructor.sourceSets.toSet()
+                        elements = pConstructor.parameters,
+                        prefix = "(",
+                        suffix = ")",
+                        separator = ", ",
+                        separatorStyles = mainStyles + TokenStyle.Punctuation,
+                        surroundingCharactersStyle = mainStyles + TokenStyle.Punctuation,
+                        sourceSets = pConstructor.sourceSets.toSet()
                     ) {
                         annotationsInline(it)
-                        text(it.name ?: "", styles = mainStyles.plus(TextStyle.Bold))
-                        text(": ")
+                        text(it.name.orEmpty())
+                        operator(": ")
                         signatureForProjection(it.type)
                     }
                 }
@@ -186,7 +197,9 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                 c.supertypes.filter { it.key == sourceSet }.map { (s, typeConstructors) ->
                     list(typeConstructors, prefix = " : ", sourceSets = setOf(s)) {
                         link(it.typeConstructor.dri.sureClassNames, it.typeConstructor.dri, sourceSets = setOf(s))
-                        list(it.typeConstructor.projections, prefix = "<", suffix = "> ") {
+                        list(it.typeConstructor.projections, prefix = "<", suffix = "> ",
+                            separatorStyles = mainStyles + TokenStyle.Punctuation,
+                            surroundingCharactersStyle = mainStyles + TokenStyle.Operator) {
                             signatureForProjection(it)
                         }
                     }
@@ -203,31 +216,42 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                 sourceSets = setOf(it)
             ) {
                 annotationsBlock(p)
-                text(p.visibility[it].takeIf { it !in ignoredVisibilities }?.name?.let { "$it " } ?: "")
-                text(
-                    p.modifier[it].takeIf { it !in ignoredModifiers }?.let {
+                p.visibility[it].takeIf { it !in ignoredVisibilities }?.name?.let { keyword("$it ") }
+                p.modifier[it].takeIf { it !in ignoredModifiers }?.let {
                         if (it is JavaModifier.Empty) KotlinModifier.Open else it
-                    }?.name?.let { "$it " } ?: ""
-                )
-                text(p.modifiers()[it]?.toSignatureString() ?: "")
-                p.setter?.let { text("var ") } ?: text("val ")
-                list(p.generics, prefix = "<", suffix = "> ") {
+                    }?.name?.let { keyword("$it ") }
+                p.modifiers()[it]?.toSignatureString()?.let { keyword(it) }
+                p.setter?.let { keyword("var ") } ?: keyword("val ")
+                list(p.generics, prefix = "<", suffix = "> ",
+                    separatorStyles = mainStyles + TokenStyle.Punctuation,
+                    surroundingCharactersStyle = mainStyles + TokenStyle.Operator) {
                     annotationsInline(it)
                     +buildSignature(it)
                 }
                 p.receiver?.also {
                     signatureForProjection(it.type)
-                    text(".")
+                    punctuation(".")
                 }
                 link(p.name, p.dri)
-                text(": ")
+                operator(": ")
                 signatureForProjection(p.type)
                 p.extra[DefaultValue]?.run {
-                    text(" = $value")
+                    operator(" = ")
+                    highlightValue(value)
                 }
             }
         }
 
+    private fun PageContentBuilder.DocumentableContentBuilder.highlightValue(expr: Expression) = when (expr) {
+        is IntegerConstant -> constant(expr.value.toString())
+        is FloatConstant -> constant(expr.value.toString() + "f")
+        is DoubleConstant -> constant(expr.value.toString())
+        is BooleanConstant -> booleanLiteral(expr.value)
+        is StringConstant -> stringLiteral("\"${expr.value}\"")
+        is ComplexExpression -> text(expr.value)
+        else ->  Unit
+    }
+
     private fun functionSignature(f: DFunction) =
         f.sourceSets.map {
             contentBuilder.contentFor(
@@ -237,37 +261,40 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                 sourceSets = setOf(it)
             ) {
                 annotationsBlock(f)
-                text(f.visibility[it]?.takeIf { it !in ignoredVisibilities }?.name?.let { "$it " } ?: "")
-                text(f.modifier[it]?.takeIf { it !in ignoredModifiers }?.let {
+                f.visibility[it]?.takeIf { it !in ignoredVisibilities }?.name?.let { keyword("$it ") }
+                f.modifier[it]?.takeIf { it !in ignoredModifiers }?.let {
                     if (it is JavaModifier.Empty) KotlinModifier.Open else it
-                }?.name?.let { "$it " } ?: ""
-                )
-                text(f.modifiers()[it]?.toSignatureString() ?: "")
-                text("fun ")
+                }?.name?.let { keyword("$it ") }
+                f.modifiers()[it]?.toSignatureString()?.let { keyword(it) }
+                keyword("fun ")
                 val usedGenerics = if (f.isConstructor) f.generics.filter { f uses it } else f.generics
-                list(usedGenerics, prefix = "<", suffix = "> ") {
+                list(usedGenerics, prefix = "<", suffix = "> ",
+                    separatorStyles = mainStyles + TokenStyle.Punctuation,
+                    surroundingCharactersStyle = mainStyles + TokenStyle.Operator) {
                     annotationsInline(it)
                     +buildSignature(it)
                 }
                 f.receiver?.also {
                     signatureForProjection(it.type)
-                    text(".")
+                    punctuation(".")
                 }
-                link(f.name, f.dri)
-                text("(")
-                list(f.parameters) {
+                link(f.name, f.dri, styles = mainStyles + TokenStyle.Function)
+                punctuation("(")
+                list(f.parameters,
+                    separatorStyles = mainStyles + TokenStyle.Punctuation) {
                     annotationsInline(it)
                     processExtraModifiers(it)
                     text(it.name!!)
-                    text(": ")
+                    operator(": ")
                     signatureForProjection(it.type)
                     it.extra[DefaultValue]?.run {
-                        text(" = $value")
+                        operator(" = ")
+                        highlightValue(value)
                     }
                 }
-                text(")")
+                punctuation(")")
                 if (f.documentReturnType()) {
-                    text(": ")
+                    operator(": ")
                     signatureForProjection(f.type)
                 }
             }
@@ -291,11 +318,11 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                         sourceSets = platforms.toSet()
                     ) {
                         annotationsBlock(t)
-                        text(t.visibility[it]?.takeIf { it !in ignoredVisibilities }?.name?.let { "$it " } ?: "")
+                        t.visibility[it]?.takeIf { it !in ignoredVisibilities }?.name?.let { keyword("$it ") }
                         processExtraModifiers(t)
-                        text("typealias ")
+                        keyword("typealias ")
                         signatureForProjection(t.type)
-                        text(" = ")
+                        operator(" = ")
                         signatureForTypealiasTarget(t, type)
                     }
                 }
@@ -306,7 +333,8 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
         t.sourceSets.map {
             contentBuilder.contentFor(t, styles = t.stylesIfDeprecated(it), sourceSets = setOf(it)) {
                 signatureForProjection(t.variantTypeParameter.withDri(t.dri.withTargetToDeclaration()))
-                list(t.nontrivialBounds, prefix = " : ") { bound ->
+                list(t.nontrivialBounds, prefix = " : ",
+                surroundingCharactersStyle = mainStyles + TokenStyle.Operator) { bound ->
                     signatureForProjection(bound)
                 }
             }
@@ -338,24 +366,29 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
                     val linkText = if (showFullyQualifiedName && p.dri.packageName != null) {
                         "${p.dri.packageName}.${p.dri.classNames.orEmpty()}"
                     } else p.dri.classNames.orEmpty()
-                    if (p.presentableName != null) text(p.presentableName + ": ")
+                    if (p.presentableName != null) {
+                        text(p.presentableName!!)
+                        operator(": ")
+                    }
                     annotationsInline(p)
                     link(linkText, p.dri)
-                    list(p.projections, prefix = "<", suffix = ">") {
+                    list(p.projections, prefix = "<", suffix = ">",
+                        separatorStyles = mainStyles + TokenStyle.Punctuation,
+                        surroundingCharactersStyle = mainStyles + TokenStyle.Operator) {
                         signatureForProjection(it, showFullyQualifiedName)
                     }
                 }
 
             is Variance<*> -> group(styles = emptySet()) {
-                text("$p ".takeIf { it.isNotBlank() } ?: "")
+                keyword("$p ".takeIf { it.isNotBlank() } ?: "")
                 signatureForProjection(p.inner, showFullyQualifiedName)
             }
 
-            is Star -> text("*")
+            is Star -> operator("*")
 
             is Nullable -> group(styles = emptySet()) {
                 signatureForProjection(p.inner, showFullyQualifiedName)
-                text("?")
+                operator("?")
             }
 
             is TypeAliased -> signatureForProjection(p.typeAlias)
@@ -373,12 +406,15 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
     private fun funType(dri: DRI, sourceSets: Set<DokkaSourceSet>, type: FunctionalTypeConstructor) =
         contentBuilder.contentFor(dri, sourceSets, ContentKind.Main) {
 
-            if (type.presentableName != null) text(type.presentableName + ": ")
-            if (type.isSuspendable) text("suspend ")
+            if (type.presentableName != null) {
+                text(type.presentableName!!)
+                operator(": ")
+            }
+            if (type.isSuspendable) keyword("suspend ")
 
             if (type.isExtensionFunction) {
                 signatureForProjection(type.projections.first())
-                text(".")
+                punctuation(".")
             }
 
             val args = if (type.isExtensionFunction)
@@ -386,12 +422,13 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             else
                 type.projections
 
-            text("(")
+            punctuation("(")
             args.subList(0, args.size - 1).forEachIndexed { i, arg ->
                 signatureForProjection(arg)
-                if (i < args.size - 2) text(", ")
+                if (i < args.size - 2) punctuation(", ")
             }
-            text(") -> ")
+            punctuation(")")
+            operator(" -> ")
             signatureForProjection(args.last())
         }
 }