aboutsummaryrefslogtreecommitdiff
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/src/main/kotlin/javadoc/docbase.kt121
1 files changed, 62 insertions, 59 deletions
diff --git a/core/src/main/kotlin/javadoc/docbase.kt b/core/src/main/kotlin/javadoc/docbase.kt
index 118b134a..ace4ae0c 100644
--- a/core/src/main/kotlin/javadoc/docbase.kt
+++ b/core/src/main/kotlin/javadoc/docbase.kt
@@ -84,7 +84,7 @@ open class DocumentationNodeAdapter(override val module: ModuleNodeAdapter, node
// should be extension property but can't because of KT-8745
private fun <T> nodeAnnotations(self: T): List<AnnotationDescAdapter> where T : HasModule, T : HasDocumentationNode
- = self.node.annotations.map { AnnotationDescAdapter(self.module, it) }
+ = self.node.annotations.map { AnnotationDescAdapter(self.module, it) }
private fun DocumentationNode.hasAnnotation(klass: KClass<*>) = klass.qualifiedName in annotations.map { it.qualifiedName() }
private fun DocumentationNode.hasModifier(name: String) = details(NodeKind.Modifier).any { it.name == name }
@@ -94,7 +94,7 @@ class PackageAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : Docum
private val allClasses = listOf(node).collectAllTypesRecursively()
override fun findClass(className: String?): ClassDoc? =
- allClasses.get(className)?.let { ClassDocumentationNodeAdapter(module, it) }
+ allClasses.get(className)?.let { ClassDocumentationNodeAdapter(module, it) }
override fun annotationTypes(): Array<out AnnotationTypeDoc> = emptyArray()
override fun annotations(): Array<out AnnotationDesc> = node.members(NodeKind.AnnotationClass).map { AnnotationDescAdapter(module, it) }.toTypedArray()
@@ -126,9 +126,9 @@ open class ProgramElementAdapter(module: ModuleNodeAdapter, node: DocumentationN
override fun modifierSpecifier(): Int = visibilityModifier or (if (isStatic) STATIC else 0)
private val visibilityModifier
get() = when {
- isPublic() -> PUBLIC
- isPrivate() -> PRIVATE
- isProtected() -> PROTECTED
+ isPublic -> PUBLIC
+ isPrivate -> PRIVATE
+ isProtected -> PROTECTED
else -> 0
}
override fun qualifiedName(): String? = node.qualifiedName()
@@ -185,24 +185,24 @@ open class TypeAdapter(override val module: ModuleNodeAdapter, override val node
override fun isPrimitive(): Boolean = simpleTypeName() in setOf("int", "long", "short", "byte", "char", "double", "float", "boolean", "void")
override fun asClassDoc(): ClassDoc? = if (isPrimitive) null else
- elementType?.asClassDoc() ?:
- when (node.kind) {
- in NodeKind.classLike,
- NodeKind.ExternalClass,
- NodeKind.Exception -> module.classNamed(qualifiedTypeName()) ?: ClassDocumentationNodeAdapter(module, node)
-
- else -> when {
- node.links.isNotEmpty() -> TypeAdapter(module, node.links.first()).asClassDoc()
- else -> ClassDocumentationNodeAdapter(module, node) // TODO ?
- }
+ elementType?.asClassDoc() ?:
+ when (node.kind) {
+ in NodeKind.classLike,
+ NodeKind.ExternalClass,
+ NodeKind.Exception -> module.classNamed(qualifiedTypeName()) ?: ClassDocumentationNodeAdapter(module, node)
+
+ else -> when {
+ node.links.isNotEmpty() -> TypeAdapter(module, node.links.first()).asClassDoc()
+ else -> ClassDocumentationNodeAdapter(module, node) // TODO ?
}
+ }
override fun asTypeVariable(): TypeVariable? = if (node.kind == NodeKind.TypeParameter) TypeVariableAdapter(module, node) else null
override fun asParameterizedType(): ParameterizedType? =
- if (node.details(NodeKind.Type).isNotEmpty() && javaLanguageService.getArrayElementType(node) == null)
- ParameterizedTypeAdapter(module, node)
- else
- null
+ if (node.details(NodeKind.Type).isNotEmpty() && javaLanguageService.getArrayElementType(node) == null)
+ ParameterizedTypeAdapter(module, node)
+ else
+ null
override fun asAnnotationTypeDoc(): AnnotationTypeDoc? = if (node.kind == NodeKind.AnnotationClass) AnnotationTypeDocAdapter(module, node) else null
override fun asAnnotatedType(): AnnotatedType? = if (node.annotations.isNotEmpty()) AnnotatedTypeAdapter(module, node) else null
@@ -258,15 +258,15 @@ class TypeVariableAdapter(module: ModuleNodeAdapter, node: DocumentationNode) :
class ParameterizedTypeAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : TypeAdapter(module, node), ParameterizedType {
override fun typeArguments(): Array<out Type> = node.details(NodeKind.Type).map { TypeVariableAdapter(module, it) }.toTypedArray()
override fun superclassType(): Type? =
- node.lookupSuperClasses(module)
- .firstOrNull { it.kind == NodeKind.Class || it.kind == NodeKind.ExternalClass }
- ?.let { ClassDocumentationNodeAdapter(module, it) }
+ node.lookupSuperClasses(module)
+ .firstOrNull { it.kind == NodeKind.Class || it.kind == NodeKind.ExternalClass }
+ ?.let { ClassDocumentationNodeAdapter(module, it) }
override fun interfaceTypes(): Array<out Type> =
- node.lookupSuperClasses(module)
- .filter { it.kind == NodeKind.Interface }
- .map { ClassDocumentationNodeAdapter(module, it) }
- .toTypedArray()
+ node.lookupSuperClasses(module)
+ .filter { it.kind == NodeKind.Interface }
+ .map { ClassDocumentationNodeAdapter(module, it) }
+ .toTypedArray()
override fun containingType(): Type? = when (node.owner?.kind) {
NodeKind.Package -> null
@@ -307,7 +307,7 @@ fun classOf(fqName: String, kind: NodeKind = NodeKind.Class) = DocumentationNode
}
private fun DocumentationNode.hasNonEmptyContent() =
- this.content.summary !is ContentEmpty || this.content.description !is ContentEmpty || this.content.sections.isNotEmpty()
+ this.content.summary !is ContentEmpty || this.content.description !is ContentEmpty || this.content.sections.isNotEmpty()
open class ExecutableMemberAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : ProgramElementAdapter(module, node), ExecutableMemberDoc {
@@ -317,17 +317,17 @@ open class ExecutableMemberAdapter(module: ModuleNodeAdapter, node: Documentatio
override fun thrownExceptions(): Array<out ClassDoc> = emptyArray() // TODO
override fun throwsTags(): Array<out ThrowsTag> =
- node.content.sections
- .filter { it.tag == ContentTags.Exceptions && it.subjectName != null }
- .map { ThrowsTagAdapter(this, ClassDocumentationNodeAdapter(module, classOf(it.subjectName!!, NodeKind.Exception)), it.children) }
- .toTypedArray()
+ node.content.sections
+ .filter { it.tag == ContentTags.Exceptions && it.subjectName != null }
+ .map { ThrowsTagAdapter(this, ClassDocumentationNodeAdapter(module, classOf(it.subjectName!!, NodeKind.Exception)), it.children) }
+ .toTypedArray()
override fun isVarArgs(): Boolean = node.details(NodeKind.Parameter).last().hasModifier("vararg")
override fun isSynchronized(): Boolean = node.annotations.any { it.name == "synchronized" }
override fun paramTags(): Array<out ParamTag> =
- collectParamTags(NodeKind.Parameter, sectionFilter = { it.subjectName in parameters().map { it.name() } })
+ collectParamTags(NodeKind.Parameter, sectionFilter = { it.subjectName in parameters().map { it.name() } })
override fun thrownExceptionTypes(): Array<out Type> = emptyArray()
override fun receiverType(): Type? = receiverNode()?.let { receiver -> TypeAdapter(module, receiver) }
@@ -335,14 +335,14 @@ open class ExecutableMemberAdapter(module: ModuleNodeAdapter, node: Documentatio
override fun signature(): String = node.details(NodeKind.Parameter).map { JavaLanguageService().renderType(it) }.joinToString(", ", "(", ")") // TODO it should be FQ types
override fun parameters(): Array<out Parameter> =
- ((receiverNode()?.let { receiver -> listOf<Parameter>(ReceiverParameterAdapter(module, receiver, this)) } ?: emptyList())
- + node.details(NodeKind.Parameter).map { ParameterAdapter(module, it) }
- ).toTypedArray()
+ ((receiverNode()?.let { receiver -> listOf<Parameter>(ReceiverParameterAdapter(module, receiver, this)) } ?: emptyList())
+ + node.details(NodeKind.Parameter).map { ParameterAdapter(module, it) }
+ ).toTypedArray()
override fun typeParameters(): Array<out TypeVariable> = node.details(NodeKind.TypeParameter).map { TypeVariableAdapter(module, it) }.toTypedArray()
override fun typeParamTags(): Array<out ParamTag> =
- collectParamTags(NodeKind.TypeParameter, sectionFilter = { it.subjectName in typeParameters().map { it.simpleTypeName() } })
+ collectParamTags(NodeKind.TypeParameter, sectionFilter = { it.subjectName in typeParameters().map { it.simpleTypeName() } })
private fun receiverNode() = node.details(NodeKind.Receiver).let { receivers ->
when {
@@ -400,8 +400,11 @@ class FieldAdapter(module: ModuleNodeAdapter, node: DocumentationNode) : Program
}
open class ClassDocumentationNodeAdapter(module: ModuleNodeAdapter, val classNode: DocumentationNode)
: ProgramElementAdapter(module, classNode),
- Type by TypeAdapter(module, classNode),
- ClassDoc {
+ Type by TypeAdapter(module, classNode),
+ ClassDoc,
+ AnnotationTypeDoc {
+
+ override fun elements(): Array<out AnnotationTypeElementDoc>? = emptyArray() // TODO
override fun name(): String {
val parent = classNode.owner
@@ -427,17 +430,17 @@ open class ClassDocumentationNodeAdapter(module: ModuleNodeAdapter, val classNod
override fun enumConstants(): Array<out FieldDoc>? = classNode.members(NodeKind.EnumItem).map { FieldAdapter(module, it) }.toTypedArray()
override fun isAbstract(): Boolean = classNode.details(NodeKind.Modifier).any { it.name == "abstract" }
override fun interfaceTypes(): Array<out Type> = classNode.lookupSuperClasses(module)
- .filter { it.kind == NodeKind.Interface }
- .map { ClassDocumentationNodeAdapter(module, it) }
- .toTypedArray()
+ .filter { it.kind == NodeKind.Interface }
+ .map { ClassDocumentationNodeAdapter(module, it) }
+ .toTypedArray()
override fun interfaces(): Array<out ClassDoc> = classNode.lookupSuperClasses(module)
- .filter { it.kind == NodeKind.Interface }
- .map { ClassDocumentationNodeAdapter(module, it) }
- .toTypedArray()
+ .filter { it.kind == NodeKind.Interface }
+ .map { ClassDocumentationNodeAdapter(module, it) }
+ .toTypedArray()
override fun typeParamTags(): Array<out ParamTag> =
- collectParamTags(NodeKind.TypeParameter, sectionFilter = { it.subjectName in typeParameters().map { it.simpleTypeName() } })
+ collectParamTags(NodeKind.TypeParameter, sectionFilter = { it.subjectName in typeParameters().map { it.simpleTypeName() } })
override fun fields(): Array<out FieldDoc> = fields(true)
override fun fields(filter: Boolean): Array<out FieldDoc> = classNode.members(NodeKind.Field).map { FieldAdapter(module, it) }.toTypedArray()
@@ -477,10 +480,10 @@ open class ClassDocumentationNodeAdapter(module: ModuleNodeAdapter, val classNod
}
fun DocumentationNode.lookupSuperClasses(module: ModuleNodeAdapter) =
- details(NodeKind.Supertype)
- .map { it.links.firstOrNull() }
- .map { module.allTypes[it?.qualifiedName()] }
- .filterNotNull()
+ details(NodeKind.Supertype)
+ .map { it.links.firstOrNull() }
+ .map { module.allTypes[it?.qualifiedName()] }
+ .filterNotNull()
fun List<DocumentationNode>.collectAllTypesRecursively(): Map<String, DocumentationNode> {
val result = hashMapOf<String, DocumentationNode>()
@@ -504,19 +507,19 @@ class ModuleNodeAdapter(val module: DocumentationModule, val reporter: DocErrorR
override fun packageNamed(name: String?): PackageDoc? = allPackages[name]?.let { PackageAdapter(this, it) }
override fun classes(): Array<out ClassDoc> =
- allTypes.values.map { ClassDocumentationNodeAdapter(this, it) }.toTypedArray()
+ allTypes.values.map { ClassDocumentationNodeAdapter(this, it) }.toTypedArray()
override fun options(): Array<out Array<String>> = arrayOf(
- arrayOf("-d", outputPath),
- arrayOf("-docencoding", "UTF-8"),
- arrayOf("-charset", "UTF-8"),
- arrayOf("-keywords")
+ arrayOf("-d", outputPath),
+ arrayOf("-docencoding", "UTF-8"),
+ arrayOf("-charset", "UTF-8"),
+ arrayOf("-keywords")
)
override fun specifiedPackages(): Array<out PackageDoc>? = module.members(NodeKind.Package).map { PackageAdapter(this, it) }.toTypedArray()
override fun classNamed(qualifiedName: String?): ClassDoc? =
- allTypes[qualifiedName]?.let { ClassDocumentationNodeAdapter(this, it) }
+ allTypes[qualifiedName]?.let { ClassDocumentationNodeAdapter(this, it) }
override fun specifiedClasses(): Array<out ClassDoc> = classes()
}
@@ -526,9 +529,9 @@ private fun DocumentationNodeAdapter.collectParamTags(kind: NodeKind, sectionFil
.filter(DocumentationNode::hasNonEmptyContent)
.map { ParamTagAdapter(module, this, it.name, true, it.content.children) }
- + node.content.sections
+ + node.content.sections
.filter(sectionFilter)
.map { ParamTagAdapter(module, this, it.subjectName ?: "?", true, it.children) }
- )
- .distinctBy { it.parameterName }
- .toTypedArray() \ No newline at end of file
+ )
+ .distinctBy { it.parameterName }
+ .toTypedArray() \ No newline at end of file
generated by cgit (git 2.46.0) at 2024-11-30 21:20:56 +0000