1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
package org.jetbrains.dokka.kotlinAsJava.signatures
import org.jetbrains.dokka.base.signatures.SignatureProvider
import org.jetbrains.dokka.base.transformers.pages.comments.CommentsToContentConverter
import org.jetbrains.dokka.base.translators.documentables.PageContentBuilder
import org.jetbrains.dokka.links.DRI
import org.jetbrains.dokka.links.sureClassNames
import org.jetbrains.dokka.model.*
import org.jetbrains.dokka.pages.ContentKind
import org.jetbrains.dokka.pages.ContentNode
import org.jetbrains.dokka.pages.TextStyle
import org.jetbrains.dokka.utilities.DokkaLogger
class JavaSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLogger) : SignatureProvider {
private val contentBuilder = PageContentBuilder(ctcc, this, logger)
private val ignoredVisibilities = setOf(JavaVisibility.Default, KotlinVisibility.Public)
private val ignoredModifiers =
setOf(KotlinModifier.Open, JavaModifier.Empty, KotlinModifier.Empty, KotlinModifier.Sealed)
override fun signature(documentable: Documentable): ContentNode = when (documentable) {
is DFunction -> signature(documentable)
is DProperty -> signature(documentable)
is DClasslike -> signature(documentable)
is DEnumEntry -> signature(documentable)
is DTypeParameter -> signature(documentable)
else -> throw NotImplementedError(
"Cannot generate signature for ${documentable::class.qualifiedName} ${documentable.name}"
)
}
private fun signature(e: DEnumEntry)= contentBuilder.contentFor(e, ContentKind.Symbol, setOf(TextStyle.Monospace))
private fun signature(c: DClasslike) = contentBuilder.contentFor(c, ContentKind.Symbol, setOf(TextStyle.Monospace)) {
platformText(c.visibility) { (it.takeIf { it !in ignoredVisibilities }?.name ?: "") + " " }
if (c is DClass) {
platformText(c.modifier){ it.takeIf{it !in ignoredModifiers}?.name.orEmpty() + " "}
}
when (c) {
is DClass -> text("class ")
is DInterface -> text("interface ")
is DEnum -> text("enum ")
is DObject -> text("class ")
is DAnnotation -> text("@interface ")
}
link(c.name!!, c.dri)
if (c is WithGenerics) {
list(c.generics, prefix = "<", suffix = ">") {
+buildSignature(it)
}
}
if (c is WithSupertypes) {
c.supertypes.map { (p, dris) ->
list(dris, prefix = " extends ", sourceSets = setOf(p)) {
link(it.sureClassNames, it, sourceSets = setOf(p))
}
}
}
}
private fun signature(p: DProperty) = contentBuilder.contentFor(p, ContentKind.Symbol, setOf(TextStyle.Monospace)) {
signatureForProjection(p.type)
}
private fun signature(f: DFunction) = contentBuilder.contentFor(f, ContentKind.Symbol, setOf(TextStyle.Monospace)) {
platformText(f.modifier){ it.takeIf{it !in ignoredModifiers}?.name.orEmpty() + " "}
val returnType = f.type
signatureForProjection(returnType)
text(" ")
link(f.name, f.dri)
list(f.generics, prefix = "<", suffix = ">") {
+buildSignature(it)
}
text("(")
list(f.parameters) {
signatureForProjection(it.type)
text(" ")
link(it.name!!, it.dri)
}
text(")")
}
private fun signature(t: DTypeParameter) = contentBuilder.contentFor(t) {
text(t.name.substringAfterLast("."))
list(t.bounds, prefix = " extends ") {
signatureForProjection(it)
}
}
private fun PageContentBuilder.DocumentableContentBuilder.signatureForProjection(p: Projection): Unit = when (p) {
is OtherParameter -> text(p.name)
is TypeConstructor -> group {
link(p.dri.classNames.orEmpty(), p.dri)
list(p.projections, prefix = "<", suffix = ">") {
signatureForProjection(it)
}
}
is Variance -> group {
text(p.kind.toString() + " ") // TODO: "super" && "extends"
signatureForProjection(p.inner)
}
is Star -> text("?")
is Nullable -> signatureForProjection(p.inner)
is JavaObject -> link("Object", DRI("java.lang", "Object"))
is Void -> text("void")
is PrimitiveJavaType -> text(p.name)
}
}
|
